Agent Communication Model

This note defines how Athena, ELT role agents, execution roles, and Hermes primitives should communicate.

Core Principle

Athena is the orchestrator and synthesis layer.

Role agents are not decorative personas. A role becomes live when it needs independent memory, evolving judgment, long-running dialogue, recurring work, distinct tools, distinct permissions, scheduled work, or a separate artifact stream.

Do not invent a separate inter-agent protocol until Hermes' native primitives are exhausted.

Native Hermes Primitives

Role Card / Athena Simulation

Use this for quick critique, lightweight planning, or when the role does not need durable independent memory.

delegate_task

Use this for short, synchronous, non-durable parallel reasoning.

Rules:

• Athena must pass the full packet because the child starts with fresh context.
• The child returns a final summary.
• It should not be used for work that must survive interruptions.
• It is useful for quick research, critique, or side-by-side role perspectives.

Kanban

Use this for durable multi-role work.

Rules:

• The task body carries the delegation packet.
• Comments are the durable inter-agent thread.
• kanban_complete(summary, metadata) is the structured handoff.
• kanban_block(reason) is the blocker/escalation path.
• Use this when work crosses role boundaries, needs human input, must survive restarts, or needs an audit trail.

Live Hermes Profile

Use this when a role needs its own identity and memory.

Live profile triggers:

• Persistent role-specific memory.
• Evolving judgment across multiple conversations.
• Repeated founder/advisor dialogue.
• Distinct system prompt.
• Distinct tools or permissions.
• Recurring scheduled work.
• Separate artifact destination.

Profiles are not sandboxes by themselves. Permissions and working directories still need explicit configuration.

Profile Distribution

Use this only when a profile needs to be portable across machines or shared as a reusable agent package.

Communication Hierarchy

1. Athena alone for simple status, note routing, direct execution, and small synthesis.
2. Role card when a decision needs a perspective but not durable role memory.
3. delegate_task when Athena needs short parallel reasoning inside one turn.
4. Kanban when work needs durable handoff, comments, audit trail, or multiple roles over time.
5. Live Hermes profile when the role needs independent memory, identity, and repeated advisory interaction.
6. Dedicated Telegram bot only after a live profile proves it needs a distinct user experience or notification channel.

Role Output Envelope

Use this shape for both delegate_task results and Kanban metadata.

role_output:
  schema_version: "1.0"
  role: ""
  task_id: null
  mode: "role_card|delegate_task|kanban|live_profile"
  verdict: "go|no_go|refine|blocked"
  summary: ""
  key_findings: []
  recommendation: ""
  assumptions: []
  evidence:
    citations: []
    artifacts_reviewed: []
    verification: []
  risks:
    material_risks: []
    residual_risk: []
  open_questions: []
  next_artifact: ""
  escalation:
    needed: false
    target: null
    reason: null
    decision_needed: null
  handoff:
    downstream_roles: []
    dependencies: []
    suggested_kanban_children: []

Athena Synthesis

Athena should not concatenate role outputs.

She should normalize role outputs, compare conflicts, identify the decision needed from Arijit, select the minimum roles needed next, and return:

• Decision needed from Arijit.
• Recommended plan.
• Execution team required.
• First milestone.
• Kill criteria or revisit trigger.

Escalation Rules

Use blocked only when the role cannot proceed.

Use refine when the idea is promising but missing assumptions, evidence, or scope discipline.

Ask Arijit when the next step changes budget, strategy, permission boundaries, public exposure, risk appetite, or long-term direction.

Ask Athena when routing, context, workspace ownership, or artifact shape is unclear.

Default Current Posture

The live advisory council is being built deliberately, not all at once.

Current existing advisory profiles:

1. CTO: Vulcan (vulcan).
2. Product / UX Strategy: Arjuna (arjuna).
3. Business / Revenue: Kubera (kubera).
4. Legal / Risk: Prometheus (prometheus).

Deferred:

• COO becomes live only when My OS has enough recurring operating state to justify a separate operator memory.
• CFO and CMO remain role cards until their memory stream or interaction cadence becomes distinct enough to justify live profiles.