Intent — Multi-Agent MCP Architecture

00

Three-Layer Architecture

The v1.0 Intent architecture stacks three layers: compiled knowledge, transformation OS, and executable specifications. Data flows bidirectionally through six connected feedback loops that drive continuous improvement.

Layer 1: Knowledge Base

Compiled knowledge artifacts extracted from raw sources. Personas, journeys, decisions, themes, domain models, and rationales live here. The Knowledge Engine product (intent-knowledge server) ingest raw sources, synthesize domain models, and lint for contradictions and coverage gaps.

Layer 2: Transformation OS

The Intent methodology loop: Notice, Spec, Execute, Observe. Signals bubble up from domain knowledge or raw observations. Specs are written against the knowledge base. Execution is trust-gated. Observations close the loop and update models.

Layer 3: Software & Code

Generated specifications (src/), software artifacts, and running code. This layer is output-only from the system's perspective — agents write specs that compilers translate to code, but code updates flow back as events for observation and learning.

Data Flows

Six bidirectional data flows drive the system:

Flow 1: Knowledge → NoticeLint surfaces signals. Contradictions, orphans, and coverage gaps in the knowledge base bubble up as new signals for prioritization.
Flow 2: Notice → SpecSpec authoring queries the knowledge base. Notice agents retrieve personas, journeys, and domain models to inform specification writing.
Flow 3: Spec → ExecuteTrust-gated agents build against specs. Autonomy levels are determined by trust scores. Specs are contracts that define verifiable outcomes.
Flow 4: Execute → ObserveRunning code emits events (OTel-compatible). Every action generates observability signals: logs, metrics, traces, and domain events.
Flow 5: Observe → KnowledgeDouble-loop learning. Observations update domain models, personas, and decision records. New insights update the knowledge base directly.
Flow 6: Observe → SpecSingle-loop drift detection. Compare specified behavior against actual behavior. Drift becomes a signal for spec revision.

01

How It Maps to the Loop

The Intent loop — Notice → Spec → Execute → Observe — maps to four MCP servers and a set of Claude Code subagents. Each server owns one or more domains. Each subagent connects to the relevant servers.

  ╔═══════════╗  ╔═══════════╗    ╔═══════════╗    ╔═══════════╗
  ║ KNOWLEDGE ║  ║  NOTICE   ║→→║   SPEC    ║→→║  OBSERVE  ║
  ║  Server   ║  ║  Server   ║    ║  Server   ║    ║  Server   ║
  ╚═════╩═════╝  ╚═════╩═════╝    ╚═════╩═════╝    ╚═════╩═════╝
      │       │                │                │
   Knowledge   Signals          Specs & Contracts    Events
   Models      Intents          Agent-Readiness     Deltas
   Lint        Trust Scoring    Contract Verify     Health
   Artifacts   Clustering       Promotion      Loop-back signals
              Amplification                       │
      │       │                                       │
      │       ◀───────────────────────────────────────┘
      │             observe → notice (loop closes)
      │
      ╜──────────────────────────────────────────────────────────────────────────╞
         lint surfaces knowledge signals / observe → knowledge (double-loop)

02

Four Servers, Four Domains

Each server owns a domain of the system and exposes tools that subagents call through MCP. Together they form the runtime backbone of Intent.

intent-knowledge

Port 8004

Phase: Knowledge

Compiled knowledge base operations. Ingest raw sources into domain knowledge, query the knowledge base for informed specification, and lint for contradictions, orphans, and coverage gaps. Redaction is automatic — the server applies confidentiality projection based on engagement context.

ingest — Compile raw source into knowledge artifacts
query — Synthesize answer from compiled knowledge
lint — Detect contradictions, orphans, staleness, coverage gaps
list_artifacts — Browse knowledge base
get_artifact — Read specific artifact

intent-notice

Port 8001

Phase: Notice

Signal lifecycle from capture through promotion to intent. This is the upstream layer — the part Intent argues is the real bottleneck when AI collapses implementation cost.

create_signal — Capture with trust scoring + autonomy level
score_trust — Rescore trust factors, detect autonomy boundary crossings
cluster_signals — Group related signals by emergent theme
promote_to_intent — Promote cluster to INT-NNN (problem worth solving)
add_reference — Track signal amplification (7-day half-life decay)
dismiss_signal — Remove from active pipeline
list_signals / get_signal — Query with filters
get_events — Read the notice-phase event stream

intent-spec

Port 8002

Phase: Spec

Specifications, contracts, and agent-readiness assessment. Specs are contracts, not stories — precise enough for autonomous agent execution.

create_spec — Generate spec from intent with completeness scoring
create_contract — Define verifiable assertion (interface | behavior | quality | integration)
verify_contract — Record verification result, emit event
assess_agent_readiness — Check if spec meets L3/L4 execution threshold
list_specs / get_spec — Query with filters

intent-observe

Port 8003

Phase: Observe

Event ingestion, delta detection, and loop closure. Every action emits events. The observer analyzes them and feeds deltas back as new signals into Notice.

ingest_event — Accept any of the 15 OTel-compatible event types
detect_spec_delta — Compare specified vs actual for a spec
detect_trust_drift — Find signals with shifting effective trust
system_health — Pipeline health across all four phases
suggest_signals_from_events — Closes the loop: observe → notice

03

Federation Model

Intent is deployed as a multi-tenant federation. Core runs the canonical Intent system. Engagements are bounded instances of Intent deployed within client environments.

Core & Engagements

Core is the universal substrate. It runs the four servers, hosts templates, and maintains the Intent methodology loop. Engagements inherit from Core but operate independently within their own contexts (Subaru, F&G, ASA, Cargill, Footlocker, etc.).

Data Flow Rules: Inherit Down, Promote Up, Never Leak Sideways

Engagements inherit knowledge bases, specifications, and templates from Core. Insights and innovations in one engagement are promoted back to Core for sharing. Data never flows directly between engagements — all cross-engagement communication flows through Core.

Engagement Rollout

Subaru (pilot) → F&G (growth) → ASA (expansion) → Cargill (enterprise) → Footlocker (retail). Each engagement brings lessons for the next. Core evolves based on real-world deployment data.

04

Schema Alignment

Every tool input and output aligns to the published Intent schemas. IDs, storage paths, and MCP servers form a consistent addressing system.

Schema	ID Format	Storage Path	MCP Server
Knowledge Artifact	`PER-NNN, JRN-NNN, DDR-NNN, THM-NNN, DOM-NNN, RAT-NNN`	`knowledge/`	intent-knowledge
Signal	`SIG-NNN`	`.intent/signals/YYYY-MM-DD-*.md`	intent-notice
Intent	`INT-NNN`	`.intent/intents/INT-NNN-*.md`	intent-notice
Spec	`SPEC-NNN`	`spec/SPEC-NNN-*.md`	intent-spec
Contract	`CON-NNN`	`spec/contracts/CON-NNN.md`	intent-spec
Event	(JSONL)	`.intent/events/events.jsonl`	intent-observe

05

Trust-Gated Autonomy

Every signal is trust-scored. The score determines how much freedom agents get when acting on it. Higher trust means more autonomy — but always with circuit breakers.

trust = clarity × 0.30 + (1/blast_radius) × 0.20 + reversibility × 0.20 + testability × 0.20 + precedent × 0.10

Level	Trust Range	Agent Behavior
L0	< 0.2	Agent only records. Human drives all.
L1	0.2 – 0.4	Agent suggests. Human decides.
L2	0.4 – 0.6	Agent proposes and awaits approval.
L3	0.6 – 0.85	Agent executes with human monitoring.
L4	≥ 0.85	Full autonomy, circuit breakers only.

06

Phased Rollout

Intent ships incrementally. Each phase adds a layer of capability without requiring the full system to be operational.

Phase 1 — Walking Skeleton

Notice + Spec

Capture signals, promote to intents, write specs with contracts. Minimum viable loop: signal → intent → spec.

Phase 2 — Close the Loop

Add Observe

Event ingestion, delta detection, suggest-signals-from-events. Full loop: notice → spec → execute → observe → notice.

Phase 3 — Agent Teams

Subagents + Coordinator

Parallel execution with trust-gated autonomy levels. Model mixing: Haiku for capture, Sonnet for spec, Opus for review.

Phase 4 — Persistence

Git-Backed Storage

Replace in-memory stores with .intent/ directory structure. Events append to events.jsonl. Full audit trail in git history.