Skip to main content

AI Agent Types & Detailed Responsibilities

Overview​

This document provides deep-dive details on each agent type in the Axiom Genesis AI system, including their specialized responsibilities, required knowledge, capabilities, and implementation patterns.

1. COMMUNICATION AGENT​

Purpose​

Interface between human users and the AI orchestration system. Handles natural language understanding, context management, and user-friendly response generation.

Key Responsibilities​

1.1 Intent Detection​

// From user message, determine what they're trying to accomplish
inputs: [
  "I need a system to track employee expenses",
  "Add approval workflow to my invoice system",
  "Generate a dashboard showing sales metrics"
]

detects: [
  { intent: "build_solution", domain: "finance" },
  { intent: "extend_solution", domain: "workflow" },
  { intent: "create_report", domain: "analytics" }
]

1.2 Context Extraction​

// Extract relevant information from user message
user_message: "Create an invoicing system for our accounting department with multi-vendor support"

extracted_context: {
  domain: "accounting",
  features: ["multi-vendor", "invoicing"],
  department: "accounting",
  scale: "departmental",
  priority_features: ["vendor_management", "invoice_tracking"]
}

1.3 Conversation History Management​

// Maintain conversation context
conversation_session: {
  user_id: "user_123",
  session_id: "sess_456",
  messages: [
    { role: "user", content: "Create invoice system", timestamp: "10:00" },
    { role: "assistant", content: "I'll help...", timestamp: "10:01" },
    { role: "user", content: "Add approval workflow", timestamp: "10:05" },
    // Current context includes all previous messages
  ],
  context_summary: {
    primary_entity: "Invoice",
    workflows_mentioned: ["processing", "approval"],
    integrations: ["email"]
  }
}

1.4 Clarification & Refinement​

// Ask user questions to clarify ambiguous requirements
user: "I need a reporting system"

agent_response: `I can help! A few clarifications:
1. What data do you want to report on? (sales, inventory, employees, etc.)
2. Who is your audience? (executives, managers, operators)
3. What format? (dashboards, exported reports, emails)
4. How often? (real-time, daily, monthly)

Please provide details so I can design the right solution.`

1.5 Progress Communication​

// Keep user informed of what's happening
user_submitted_requirements...

agent_response: `
✅ Analyzing requirements...
   └─ Detected: Invoicing system with approval workflow
   
⏳ Planning solution architecture...
   └─ Will create: Invoice, Vendor, Approval entities
   
🔄 Generating configurations...
   1/5 - Designing entities...
   2/5 - Creating workflows...
   3/5 - Building forms...
   4/5 - Setting up reports...
   5/5 - Configuring security...

📋 Summary of what I'll create:
   • 4 Data entities
   • 1 Workflow with 8 steps
   • 3 Data entry forms
   • 2 Reports
   • 4 Security roles
`

1.6 Response Formatting​

// Format AI outputs for user consumption
raw_agent_output: {
  entities: [...complex JSON...],
  workflows: [...complex JSON...],
  ...
}

user_friendly_output: `
✅ System Design Complete!

📊 What was created:

ENTITIES (4):
├── Invoice - Core invoice tracking
├── Vendor - Vendor information management
├── ApprovalRequest - Approval workflow tracking
└── ReportConfig - Dashboard configuration

🔄 WORKFLOWS (1):
├── Invoice Processing
   ├── Email Reading → Extraction → Validation
   ├── Database Storage → Approval Routing
   └── Notification → Confirmation

📋 FORMS (3):
├── Invoice Entry Form
├── Vendor Management Form
└── Approval Dashboard

📈 REPORTS (2):
├── Invoice Status Dashboard
└── Vendor Payment Summary

🔐 SECURITY (4 Roles):
├── Finance Admin - Full access
├── Finance Manager - Can approve/view
├── Finance Viewer - Read-only
└── Vendor - Limited access

NEXT STEPS:
[View Detailed Design] [Deploy System] [Refine & Modify] [Ask More Questions]
`

Required Knowledge Base​

  • Business terminology and domain language
  • Common business processes and workflows
  • Axiom Genesis capabilities
  • Solution patterns and best practices

Tools Available​

  • parseUserInput() - NLP parsing
  • extractContext() - Context extraction
  • generateFollowUpQuestions() - Clarification
  • formatResponse() - User-friendly formatting
  • storeConversationHistory() - Memory management
  • retrieveConversationContext() - Context retrieval

2. ORCHESTRATOR AGENT​

Purpose​

Master coordinator that breaks down complex requirements, plans execution, coordinates multiple sub-agents, and aggregates their outputs into a cohesive solution.

Key Responsibilities​

2.1 Requirement Decomposition​

user_requirement: "Build a complete ERP system for manufacturing"

decomposed: {
  modules: [
    {
      module: "inventory_management",
      entities: ["Product", "Warehouse", "Stock"],
      workflows: ["Stock_In", "Stock_Out", "Stock_Adjustment"],
      integrations: ["barcode_scanning"]
    },
    {
      module: "sales_management",
      entities: ["Customer", "Order", "Invoice"],
      workflows: ["Order_Processing", "Approval", "Fulfillment"],
      integrations: ["email_notification"]
    },
    {
      module: "accounting",
      entities: ["Account", "JournalEntry", "Report"],
      workflows: ["Posting", "Reconciliation"],
      integrations: ["bank_connection"]
    }
  ],
  dependencies: [
    "inventory → sales → accounting"  // Execution order
  ]
}

2.2 Agent Selection & Sequencing​

// Determine which agents are needed and in what order
execution_plan: [
  {
    phase: 1,
    parallel: true,
    tasks: [
      {
        task_id: "knowledge_prep",
        agent: "KnowledgeAgent",
        objective: "Gather manufacturing best practices, ERP standards"
      },
      {
        task_id: "template_search",
        agent: "KnowledgeAgent",
        objective: "Find similar ERP templates/patterns"
      }
    ]
  },
  {
    phase: 2,
    parallel: true,
    tasks: [
      {
        task_id: "inventory_entity",
        agent: "EntityArchitectAgent",
        objective: "Design inventory entities",
        depends_on: ["knowledge_prep"]
      },
      {
        task_id: "sales_entity",
        agent: "EntityArchitectAgent",
        objective: "Design sales entities",
        depends_on: ["knowledge_prep"]
      }
    ]
  },
  {
    phase: 3,
    parallel: true,
    tasks: [
      {
        task_id: "inventory_workflow",
        agent: "WorkflowDesignerAgent",
        objective: "Create inventory workflows",
        depends_on: ["inventory_entity"]
      },
      {
        task_id: "sales_workflow",
        agent: "WorkflowDesignerAgent",
        objective: "Create sales workflows",
        depends_on: ["sales_entity"]
      }
    ]
  }
  // ... more phases
]

2.3 Dependency Management​

// Ensure agents execute in correct order
dependency_graph: {
  "entity_design": {
    status: "completed",
    output: {...},
    blocking: ["form_design", "workflow_design"]
  },
  "form_design": {
    status: "queued",
    depends_on: ["entity_design"],
    blocking: ["ui_design"]
  },
  "workflow_design": {
    status: "waiting",
    depends_on: ["entity_design"],
    blocking: ["deployment"]
  },
  "ui_design": {
    status: "not_started",
    depends_on: ["form_design", "entity_design"],
    blocking: ["testing"]
  },
  "deployment": {
    status: "not_started",
    depends_on: ["workflow_design", "security_setup"],
    blocking: []
  }
}

2.4 State Aggregation​

// Continuously update overall project state
project_state: {
  project_id: "erp_system_2024",
  total_progress: 34,  // percent
  phase: 2,
  
  artifacts: {
    entities: { status: "in_progress", count: 12, completed: 8 },
    workflows: { status: "queued", count: 15, completed: 0 },
    forms: { status: "not_started", count: 20, completed: 0 },
    reports: { status: "not_started", count: 10, completed: 0 },
    roles: { status: "not_started", count: 5, completed: 0 }
  },
  
  timeline: {
    started: "2024-03-12T10:00:00Z",
    estimated_completion: "2024-03-12T11:30:00Z",
    elapsed: "30 minutes"
  },
  
  events: [
    { timestamp: "10:05", agent: "KnowledgeAgent", status: "completed" },
    { timestamp: "10:10", agent: "EntityArchitectAgent", status: "started", task: "customer_entity" },
    { timestamp: "10:15", agent: "EntityArchitectAgent", status: "in_progress", progress: 67 }
  ]
}

2.5 Error Handling & Recovery​

// Handle failures and reroute workflow
error_scenario: {
  task_id: "entity_design_vendor",
  agent: "EntityArchitectAgent",
  error: "Generated entity violates database constraints",
  
  recovery_plan: {
    action: "retry_with_constraints",
    modifications: {
      add_constraint: "field_names must be SQL-safe",
      add_validation: "check_against_database_restrictions"
    },
    retry_count: 1,
    retry_with_different_approach: true
  }
}

Required Knowledge Base​

  • Full set of business requirements
  • Axiom Genesis platform capabilities
  • Agent specialties and strengths
  • Solution patterns and best practices
  • Dependency relationships

Tools Available​

  • decomposeRequirements() - Break down complex needs
  • planExecution() - Create execution schedule
  • routeToAgent() - Send task to appropriate agent
  • trackProgress() - Monitor overall progress
  • aggregateResults() - Combine outputs
  • handleFailures() - Error recovery

3. KNOWLEDGE & CONTEXT AGENT (Coming Soon - Detailed)​

Purpose​

Intelligent research and context gathering, providing sub-agents with domain-specific knowledge and best practices.

Key Responsibilities​

3.1 Internet Research​

// Search for and synthesize relevant information
research_task: {
  domain: "invoice_processing",
  search_queries: [
    "invoice processing best practices 2024",
    "invoice data extraction standards",
    "invoice validation rules by country",
    "payment terms standards ISO 20022"
  ],
  sources: {
    preferred: ["github.com", "documentation sites"],
    exclude: ["ads", "sponsored content"]
  }
}

research_output: {
  best_practices: [...],
  standards: [...],
  common_fields: [...],
  validation_rules: [...],
  failure_patterns: [...],
  references: [...]
}

3.2 Template Discovery​

// Find similar solutions in knowledge base
search_criteria: {
  domain: "accounting",
  features: ["invoicing", "vendor_management", "approval"],
  scale: "enterprise",
  industry: "manufacturing"
}

found_templates: [
  {
    template_id: "accounting_erp_v3",
    similarity: 0.92,
    entities: [...],
    workflows: [...],
    lessons_learned: [...]
  },
  {
    template_id: "invoice_simple_v2",
    similarity: 0.87,
    ...
  }
]

3.3 Domain Expertise Enhancement​

// Provide specialized knowledge to other agents
EntityArchitectAgent.asks: "What fields should be in a Customer entity for a CRM?"

response: {
  standard_fields: [...typical CRM customer fields...],
  compliance_considerations: [...tax, GDPR, etc...],
  performance_tips: [...index recommendations...],
  validation_rules: [...common patterns...],
  relationships: [...typical customer relationships...],
  examples: [...]
}

Required Knowledge Base​

  • Internet access capability
  • Internal knowledge base and templates
  • Industry standards and best practices
  • Pattern library for common scenarios

Tools Available​

  • searchInternet() - Web search
  • queryKnowledgeBase() - Internal template search
  • findSimilarSolutions() - Pattern matching
  • synthesizeInformation() - Combine and summarize
  • provideBestPractices() - Domain expertise

4. ENTITY ARCHITECT AGENT​

Purpose​

Design data entities that form the foundation of any business solution.

Key Responsibilities​

4.1 Field Definition​

  • Determine entity fields based on requirements
  • Assign appropriate data types
  • Define constraints and validations
  • Set default values

4.2 Relationship Design​

  • Identify entities that need to relate
  • Determine relationship types (1:1, 1:N, M:N)
  • Define foreign key constraints
  • Plan cascading behaviors

4.3 Index & Performance Optimization​

  • Identify frequently queried fields
  • Design indexes for optimal performance
  • Plan partitioning strategies
  • Consider denormalization where needed

4.4 Security & Access Control​

  • Define field-level access controls
  • Plan audit fields (created_by, created_date, etc.)
  • Design encryption requirements
  • Plan masking for sensitive fields

Output Format​

{
  entity_id: "entity_customer",
  entity_name: "Customer",
  display_name: "Customers",
  icon: "person",
  
  fields: [
    {
      name: "customer_id",
      label: "Customer ID",
      type: "uuid",
      required: true,
      unique: true,
      primary_key: true,
      system_generated: true,
      audit: false
    },
    {
      name: "name",
      label: "Customer Name",
      type: "string",
      length: 200,
      required: true,
      searchable: true,
      sortable: true
    },
    {
      name: "email",
      label: "Email",
      type: "email",
      required: true,
      unique: true,
      validation: "email_format"
    },
    {
      name: "phone",
      label: "Phone Number",
      type: "phone",
      required: false,
      format: "international"
    },
    {
      name: "balance",
      label: "Account Balance",
      type: "decimal",
      precision: 18,
      scale: 2,
      default: 0,
      min: -999999999,
      max: 999999999
    },
    {
      name: "created_date",
      label: "Created Date",
      type: "datetime",
      system_generated: true,
      audit: true,
      sortable: true
    },
    {
      name: "created_by",
      label: "Created By",
      type: "uuid",
      system_generated: true,
      audit: true,
      references: "User"
    }
  ],
  
  relationships: [
    {
      rel_id: "customer_orders",
      type: "has_many",
      target_entity: "Order",
      foreign_key: "customer_id",
      cascading_delete: true
    },
    {
      rel_id: "customer_addresses",
      type: "has_many",
      target_entity: "Address",
      foreign_key: "customer_id",
      cascading_delete: true
    }
  ],
  
  indexes: [
    {
      name: "idx_customer_email",
      fields: ["email"],
      unique: true
    },
    {
      name: "idx_customer_created",
      fields: ["created_date"],
      order: "desc"
    },
    {
      name: "idx_customer_search",
      fields: ["name", "email"],
      fulltext: true
    }
  ],
  
  permissions: {
    create: {
      roles: ["admin", "sales_manager"],
      field_exceptions: []
    },
    read: {
      roles: ["admin", "sales_team", "support_team"],
      field_exceptions: {
        "credit_card": ["admin"],
        "ssn": ["admin"]
      }
    },
    update: {
      roles: ["admin", "sales_manager"],
      field_exceptions: {
        "balance": ["admin"],  // Only admin can change balance
        "created_by": []  // No one can change created_by
      }
    },
    delete: {
      roles: ["admin"],
      conditions: "no_active_orders"
    }
  },
  
  audit_fields: true,
  encryption_fields: ["ssn", "credit_card"],
  masking_fields: {
    "ssn": "XXX-XX-0000",
    "credit_card": "****-****-****-1234"
  }
}

5. WORKFLOW DESIGNER AGENT​

Purpose​

Design business processes and automation workflows that leverage entities and integrate systems.

Key Workflow Node Types​

// Trigger Nodes
{
  type: "webhook",
  config: { url: "...", method: "POST" }
},
{
  type: "schedule",
  config: { frequency: "daily", time: "09:00" }
},
{
  type: "email_trigger",
  config: { folder: "Invoices", filter: "*.pdf" }
},

// Processing Nodes
{
  type: "ai_extraction",
  config: { model: "invoice_extraction", fields: [...] }
},
{
  type: "validate",
  config: { rules: [{field: "amount", rule: "required"}, ...] }
},
{
  type: "lookup",
  config: { entity: "Vendor", match_field: "email" }
},
{
  type: "transform",
  config: { mappings: {...}, formulas: {...} }
},

// Action Nodes
{
  type: "entity_create",
  config: { entity: "Invoice", mapping: {...} }
},
{
  type: "entity_update",
  config: { entity: "Order", mapping: {...} }
},
{
  type: "api_call",
  config: { endpoint: "...", method: "POST" }
},

// Decision Nodes
{
  type: "condition",
  config: { conditions: [{field: "amount", operator: ">", value: 5000}] }
},
{
  type: "switch",
  config: { cases: [{condition: "...", handler: "..."}] }
},

// Notification Nodes
{
  type: "notification",
  config: { channel: "email", template: "approval_request" }
},
{
  type: "approval",
  config: { approvers: ["manager"], timeout: 86400 }
},

// Control Nodes
{
  type: "parallel",
  config: { branches: [node1, node2] }
},
{
  type: "loop",
  config: { collection: "items", item: "item" }
}

6. FORM DESIGNER AGENT​

Purpose​

Design user interfaces for data entry, editing, and viewing.

Supported Components​

  • Text input, textarea, rich text editor
  • Numeric input, currency, percentage
  • Date, time, datetime pickers
  • Dropdowns, multi-select, autocomplete
  • Checkboxes, radio buttons, toggles
  • File upload, image upload
  • Lookup/relationship fields
  • Repeating sections (sub-forms)
  • Custom HTML/components

7. REPORT BUILDER AGENT​

Purpose​

Design analytics, dashboards, and reporting interfaces.

Report Types​

  • KPI Cards
  • Tables with sorting/filtering
  • Charts (line, bar, pie, scatter, etc.)
  • Gauges and progress indicators
  • Maps and geographic visualizations
  • Custom drill-down reports
  • Scheduled exports
  • Email distribution

8. SECURITY & PERMISSION AGENT​

Purpose​

Define security models, roles, and access controls.

Capabilities​

  • Role definition and hierarchy
  • Permission assignment
  • Field-level access control
  • Row-level security
  • Data masking
  • Encryption policies
  • Audit logging rules
  • Multi-tenancy enforcement

9. INTEGRATION AGENT​

Purpose​

Configure external system connections and data exchanges.

Connection Types​

  • Email (IMAP/SMTP, OAuth)
  • Databases (MSSQL, Oracle, MongoDB)
  • REST APIs
  • SOAP services
  • File shares (FTP, SFTP)
  • Cloud storage (S3, Azure)
  • Payment gateways
  • Payment processors

10. USER INTERFACE NAVIGATION AGENT​

Purpose​

Design user experience and navigation structure.

Outputs​

  • Main navigation menu
  • Page/module hierarchy
  • Dashboard layouts
  • Quick links and shortcuts
  • Help and documentation links
  • User onboarding flows
  • Accessibility features

AGENT COMMUNICATION PROTOCOL​

Inter-Agent Messages​

// Agent asks another agent for information
{
  message_type: "ask",
  from_agent: "WorkflowDesignerAgent",
  to_agent: "EntityArchitectAgent",
  query: "What fields does the Invoice entity have?",
  context: { project_id: "..." }
}

// Response
{
  message_type: "answer",
  from_agent: "EntityArchitectAgent",
  to_agent: "WorkflowDesignerAgent",
  data: { fields: [...], relationships: [...] },
  timestamp: "..."
}

// Agent provides context to another
{
  message_type: "context",
  from_agent: "KnowledgeAgent",
  to_agent: "EntityArchitectAgent",
  context: {
    domain: "invoice_processing",
    best_practices: [...],
    standards: [...],
    field_recommendations: [...]
  }
}

CONCLUSION​

Each agent is specialized in its domain, with clear inputs, outputs, and responsibilities. Together, they form an intelligent system capable of designing and deploying complete business solutions from natural language requirements.