Understanding Agents

Agents in Kubiya are intelligent software entities that can perform tasks, answer questions, and automate workflows within your organization. They combine large language models (LLMs) with specific tools and knowledge to create targeted assistants that solve real business problems.

What Makes a Kubiya Agent?

A Kubiya agent consists of several components working together:

1. Core Intelligence: An LLM foundation that provides reasoning, language understanding, and problem-solving capabilities
2. Tools: Executable functions that extend the agent's capabilities to interact with your systems
3. Knowledge: Reference information the agent can access to make informed decisions
4. Permissions: Defined boundaries for what the agent can and cannot do
5. Conversation Memory: Ability to maintain context across interactions

Agent Anatomy

flowchart TB
  subgraph "Agent Components"
    LLM[Large Language Model] --- CORE[Core Intelligence]
    CORE --- Instructions[System Instructions]
    CORE --- Memory[Conversation Memory]
    CORE --- Personality[Behavior & Tone]
    
    subgraph "Capabilities" 
      Tools[Tool Access]
      Knowledge[Knowledge Sources]
      Functions[Function Calling]
      Workflows[Workflow Orchestration]
    end
    
    subgraph "Governance"
      Permissions[Access Controls]
      Guardrails[Safety Guardrails]
      Audit[Audit Logging]
      Approval[Approval Flows]
    end
    
    CORE --- Tools
    CORE --- Knowledge
    CORE --- Functions
    CORE --- Workflows
    
    Tools --- Permissions
    Knowledge --- Permissions
    Functions --- Guardrails
    Workflows --- Approval
    
    CORE --- Interface[User Interface]
  end
  
  Interface --- Communication{Communication Channels}
  Communication --- Slack[Slack]
  Communication --- Teams[MS Teams]
  Communication --- Web[Web UI]
  Communication --- CLI[Command Line]
  Communication --- API[API Integration]
  
  classDef core fill:#e6f7ff,stroke:#1890ff,stroke-width:2px
  classDef capabilities fill:#f6ffed,stroke:#52c41a,stroke-width:2px
  classDef governance fill:#fff7e6,stroke:#fa8c16,stroke-width:2px
  classDef channels fill:#f9f0ff,stroke:#722ed1,stroke-width:2px
  
  class LLM,CORE,Instructions,Memory,Personality,Interface core
  class Tools,Knowledge,Functions,Workflows capabilities
  class Permissions,Guardrails,Audit,Approval governance
  class Communication,Slack,Teams,Web,CLI,API channels

Key Capabilities

Kubiya agents can:

• Execute workflows: Run defined sequences of operations across multiple systems
• Answer questions: Provide information from connected knowledge sources
• Make decisions: Apply reasoning to determine the best course of action
• Handle approvals: Implement governance for sensitive operations
• Learn from usage: Improve responses based on user feedback and interaction patterns

Agent Types

Agents can be categorized by their primary function:

• Operational agents: Perform day-to-day system operations (e.g., server management, user provisioning)
• Knowledge agents: Answer questions about specific domains (e.g., HR policies, product documentation)
• Automation agents: Execute complex multi-step workflows (e.g., deployment processes, incident response)
• Advisory agents: Provide recommendations based on data analysis (e.g., cost optimization, security posture)

Creating an Agent

To create a Kubiya agent, you'll define:

1. Identity: Name, description, and purpose
2. Tools: What capabilities the agent can leverage
3. Knowledge: What information sources the agent can reference
4. Access: Who can use the agent and what it's allowed to do
5. Behavior: How the agent should approach tasks and communicate

Agents can be defined through:

• The web UI (Kubiya dashboard)
• YAML configuration files (CLI/Git)
• Terraform resources (Infrastructure as Code)
• API calls (programmatic creation)

Example Agent Configuration

name: infrastructure-helper
description: Manages cloud resources and handles infrastructure requests
type: operational
model: gpt-4-1106-preview
tools:
  - aws-ec2-manager
  - kubernetes-operator
  - cost-analyzer
knowledge_sources:
  - company-runbooks
  - aws-best-practices
access:
  users:
    - role: admin
      can: [view, execute, modify]
    - role: operator
      can: [view, execute]
  approval_required_for:
    - resource_deletion
    - production_changes

Agent Testing and Deployment

Before deploying an agent for production use:

1. Test functionality: Verify the agent performs as expected in controlled scenarios
2. Validate security: Ensure access controls and permissions work properly
3. Monitor interactions: Track how the agent responds to different queries
4. Gather feedback: Collect input from test users about agent performance
5. Iterate: Refine the agent's capabilities and responses

Once deployed, agents can be accessed through multiple channels, including Slack, Microsoft Teams, web interfaces, and API calls.

Next Steps

• Learn about Tools that extend agent capabilities
• Explore Knowledge Sources to improve agent responses
• Understand Security Controls for agent governance