Architecture

Five layers. One loop. No hidden choreography.

The architecture is deliberately narrow. It exists to make work legible as it moves from goal definition to verified outcome to retained memory.

This stack is not optimized for more agent activity. It is optimized for less ambiguity about what the organization is doing, why it is doing it, and whether the result should be trusted.

01

Goals

The organization starts with durable goal definitions: milestones, criteria, and dependencies. This is the contract for what work means.

  • Goals decompose into milestones with explicit dependencies.
  • Each criterion specifies its verification method: file check, command check, evaluator review, or human gate.
  • Progress is measured by criteria passed, not by activity volume.
02

Dispatch

A scheduler decides what is actionable and which agent should own it next. The system, not a meeting, determines who touches what.

  • Dispatch carries spec, criteria, runtime context, prior attempts, and failure evidence.
  • Agents are matched to work by role and capability rather than convenience.
  • Retry budgets and escalation thresholds prevent infinite churn.
03

Execution

Agents operate within bounded authority. They implement, review, analyze, or orchestrate, but always inside a declared role surface.

  • Executors implement and produce artifacts.
  • Reviewers verify against criteria and failure evidence.
  • Architects evaluate structural coherence before drift hardens into the system.
04

Evaluation

Every outcome is checked. Mechanical criteria use deterministic checks. Subjective criteria use explicit evaluator logic instead of passive trust.

  • Evaluation is independent of execution.
  • False passes and weak evidence are tracked as first-class failure signals.
  • Criteria that cannot be verified cleanly are a design problem, not an implementation detail.
05

Memory

Patterns, interviews, and post-mortems feed back into later cycles. The organization keeps a durable account of what succeeded and what failed.

  • Worker interviews capture friction, workarounds, and improvement suggestions.
  • Pattern detectors identify recurring strategies and failure modes.
  • Knowledge is queryable and can be injected into future dispatch context.

Operating loop

The system repeats the same narrow cycle on purpose.

01

Define goals with measurable criteria.

02

Dispatch the right role with the right context.

03

Execute inside bounded authority.

04

Evaluate every result independently.

05

Retain memory so the next cycle starts smarter.

Agent roles

Specialization is structural, not cosmetic.

Executor

Scoped authority

Produces artifacts inside a bounded directive and returns evidence for evaluation.

Reviewer

Read-only judgment

Checks outputs against criteria, failure evidence, and declared expectations.

Architect

Advisory authority

Judges structural coherence before the organization accumulates local fixes and global drift.

Orchestrator

System authority

Sequences dependencies, retries, dispatches, and escalation without becoming the executor.

Failure routing

Failures are classified before they are acted on.

Implementation bug

The work is wrong. The system should patch the implementation and rerun against the same criteria.

Infra misconfig

The environment is wrong. Missing credentials, bad permissions, or broken runtime assumptions get routed differently from code bugs.

Upstream outage

A dependent system is down or unstable. The correct behavior is to wait, retry, and preserve the evidence.

Rate limit

A provider quota was hit. The organization should back off instead of pretending the implementation failed.

Policy block

The request itself needs revision. The problem is not execution speed but request shape and allowed behavior.