ADX Orchestrator & Agent Runtime

Orchestration Engine + Agent Runtime + Workflow Engine.

The ADX Orchestrator is the brain that coordinates all agent activity in SpineWorkspace. It manages the lifecycle of every agent action, from task decomposition to execution to reconciliation.

Design Principles

1. Single orchestrator — One engine coordinates all agent activity
2. Task decomposition — Complex work is broken into executable units
3. Context assembly — Every agent gets the right context
4. Agent hand-off — Work flows between agents via A2CP
5. Observable — Every action is traced and logged

---

Components

Component	Purpose
Orchestration Engine	Coordinates multi-step agent workflows
Agent Runtime	Executes individual agent actions
Workflow Engine	Manages complex business processes
Task Decomposition	Breaks work into executable units
Context Assembly	Builds the context window for agents
Agent Hand-off (A2CP)	Transfers work between agents
State Management	Tracks workflow and agent state
Scheduling	Time-based and event-based triggers
Retries	Automatic retry on failure
Monitoring	Observability and alerting

---

Orchestration Flow

Work Item → Task Decomposition → Context Assembly → Agent Selection → Execution → Reconciliation → Memory

1. Work Item — A work item enters the orchestration pipeline
2. Task Decomposition — Broken into atomic, executable tasks
3. Context Assembly — Each task gets the right context from the Spine
4. Agent Selection — The right agent is selected based on capability and role
5. Execution — The agent executes the task
6. Reconciliation — Outcome is verified against intent
7. Memory — Learning is fed back to the Spine

---

Task Decomposition

Complex work is broken into atomic tasks:

Level	Description	Example
Work Item	High-level business objective	"Close Q3 deal with Acme"
Task Group	Related set of tasks	"Prepare proposal", "Schedule review"
Task	Single executable unit	"Draft proposal document"
Action	Atomic operation	"Insert pricing table into doc"

Decomposition Rules

• Each task has a single owner (human or agent)
• Each task has clear input/output contracts
• Tasks can be parallel or sequential
• Dependencies are explicit and enforced

---

Context Assembly

Every agent receives a context window built from the Spine:

interface AgentContext {
  workItem: WorkItem;           // The current work item
  entityContext: Entity[];      // Related entities
  eventHistory: Event[];        // Recent events
  communicationHistory: Message[]; // Recent messages
  decisions: Decision[];        // Related decisions
  risks: Risk[];                // Identified risks
  userPreferences: Preferences; // How the user works
  domainKnowledge: Knowledge[]; // Organizational patterns
}

Context Rules

• Context is role-scoped — agents only see what their role allows
• Context is time-bounded — recent events weighted more heavily
• Context is relevance-scored — most relevant information surfaces first
• Context is token-budgeted — fits within model context limits

---

Agent Selection

The orchestrator selects agents based on:

Factor	Description
Capability match	Agent has the required capability
Role scope	Agent's role matches the work domain
Availability	Agent is not overloaded or offline
Performance	Historical success rate for similar tasks
Cost	Token and compute cost within budget

---

Agent Hand-off (A2CP)

The Agent-to-Agent Communication Protocol enables work transfer:

Agent A → A2CP Message → Agent B

A2CP Message Format

interface A2CPMessage {
  from: AgentRef;
  to: AgentRef;
  workItem: WorkItemRef;
  context: ContextSnapshot;
  intent: string;
  constraints: Constraint[];
  deadline?: string;
}

Hand-off Rules

• Hand-offs are logged in the Spine
• Context is transferred, not lost
• The receiving agent can accept, reject, or delegate
• Hand-offs are governed — high-risk transfers require approval

---

State Management

The orchestrator tracks state for every workflow:

State	Description
Identified	Work item recognized
Contextualizing	Gathering context
Defined	Tasks decomposed and assigned
Allocated	Agents assigned to tasks
Deciding	Agent reasoning in progress
Governing	Governance check pending
Executing	Task being executed
Observing	Monitoring execution outcome
Re-ingesting	Processing execution results
Reconciling	Verifying intent vs. outcome
Resolved	Work item completed
Learning	Feeding back to memory
Continuing	Next cycle beginning

---

Scheduling

Trigger	Description
Event-driven	Triggered by Spine events
Time-based	Cron-like scheduled execution
Dependency-driven	Triggered when prerequisites complete
Manual	Triggered by human action
Agent-initiated	Triggered by agent recommendation

---

Monitoring & Observability

Metric	Description
Task completion rate	Percentage of tasks completed successfully
Average execution time	Time from task start to completion
Agent utilization	How busy each agent is
Error rate	Percentage of tasks that fail
Retry rate	Percentage of tasks requiring retry
Context quality	How well context assembly performs