Skip to main content

Agent Architecture

Technical deep dive into how Crella Engine agents are built and operate.

Agent Structure​

Every agent in the Crella Engine follows a consistent architecture:

flowchart TB
    subgraph agent [Agent Structure]
        Input[Input Handler]
        Validate[Validator]
        Process[Processor]
        Output[Output Handler]
        State[State Manager]
        Log[Logger]
    end
    
    Input --> Validate
    Validate --> Process
    Process --> Output
    State -.-> Process
    Log -.-> Process

Agent Interface​

Each agent implements a standard interface:

interface CrellAgent {
  codename: string;        // e.g., "ALPHA001"
  name: string;            // e.g., "Alpha"
  role: string;            // e.g., "Intake Agent"
  capabilities: string[];  // List of abilities
  
  // Configuration
  costPerTask: number;     // USD cost
  avgProcessingTime: number; // milliseconds
  
  // Methods
  process(input: TaskInput): Promise<TaskOutput>;
  validate(input: TaskInput): ValidationResult;
  getStatus(): AgentStatus;
}

Agent Types​

1. Stateless Agents​

Most agents are stateless—they process input and return output without maintaining session state.

Examples: Alpha, Bravo, Charlie, Foxtrot

flowchart LR
    In[Input] --> Agent[Stateless Agent]
    Agent --> Out[Output]

2. Stateful Agents​

Some agents maintain state across interactions.

Examples: Lima (workflow state), Kilo (learning state)

flowchart LR
    In[Input] --> Agent[Stateful Agent]
    Agent --> State[(State Store)]
    State --> Agent
    Agent --> Out[Output]

3. External Integration Agents​

Agents that call external services.

Examples: Echo (LinkedIn, Google), Hotel (Email, SMS)

flowchart LR
    In[Input] --> Agent[Integration Agent]
    Agent --> API[External API]
    API --> Agent
    Agent --> Out[Output]

Communication Protocol​

Agents communicate through a message queue system:

sequenceDiagram
    participant Lima
    participant Queue
    participant Agent
    participant Storage
    
    Lima->>Queue: Publish Task
    Queue->>Agent: Deliver Task
    Agent->>Storage: Read/Write Data
    Agent->>Queue: Publish Result
    Queue->>Lima: Deliver Result

Message Format​

{
  "taskId": "task-uuid-12345",
  "agentTarget": "ALPHA001",
  "type": "lead_validation",
  "payload": {
    "data": {...},
    "config": {...}
  },
  "metadata": {
    "source": "LIMA001",
    "priority": "high",
    "timestamp": "2026-01-16T10:00:00Z"
  }
}

Error Handling​

flowchart TB
    Task[Task Received]
    Process[Process Task]
    Success{Success?}
    Retry{Retries Left?}
    Complete[Mark Complete]
    RetryTask[Retry Task]
    Escalate[Escalate to India]
    Human[Human Review]
    
    Task --> Process
    Process --> Success
    Success -->|Yes| Complete
    Success -->|No| Retry
    Retry -->|Yes| RetryTask
    RetryTask --> Process
    Retry -->|No| Escalate
    Escalate --> Human

Retry Policy​

Agent TypeMax RetriesBackoffEscalation
Intake3ExponentialIndia
Processing2LinearIndia
Output5ExponentialIndia
Orchestration1NoneHuman

Performance Metrics​

Each agent tracks:

MetricDescription
totalTasksLifetime task count
successRatePercentage successful
avgProcessingTimeMean execution time (ms)
avgConfidenceAI confidence score (0-100)
totalCostCumulative USD spent

Agent Capabilities Matrix​

                 Alpha  Bravo  Charlie  Delta  Echo  Foxtrot  Golf  Hotel  India  Juliet  Kilo  Lima
Data Validation    ✓                                                              
Routing                   ✓                                                               ✓
OCR Processing                    ✓
Decision Logic                            ✓
External Research                               ✓
Content Gen                                            ✓
Video Gen                                                    ✓
Communication                                                       ✓
Human Routing                                                              ✓
Analytics                                                                         ✓
ML Feedback                                                                              ✓
Orchestration                                                                                   ✓

Scaling Model​

Horizontal Scaling​

Each agent can be instantiated multiple times:

flowchart LR
    subgraph pool [Alpha Agent Pool]
        A1[Alpha-1]
        A2[Alpha-2]
        A3[Alpha-3]
    end
    
    LB[Load Balancer]
    LB --> A1
    LB --> A2
    LB --> A3

Vertical Specialization​

Agents can be fine-tuned for specific domains:

flowchart TB
    subgraph generic [Generic Delta]
        DG[Delta - Base]
    end
    
    subgraph specialized [Specialized Deltas]
        DM[Delta - MoneyMatcher]
        DE[Delta - EHMP]
        DC[Delta - Custom]
    end
    
    DG --> DM
    DG --> DE
    DG --> DC

Next Steps​