Skip to main content

3-Tier Agent Architecture (No-Haiku)

Why MoAI removes Haiku from the routing model set and splits the remaining models into three task-based tiers — the DeepSWE data behind the decision, the per-tier assignment rule, and how model tiers differ from autonomy tiers.

UPDATED 2026-09-29 11 min read EDIT ON GITHUB ↗

MoAI-ADK removes Haiku from the routing model set and splits the remaining models into three tiers used according to the character of the work. This page is written so you could explain it to a friend — “Slotting a cheap model into the busy seats looks like it saves money, but on long-horizon tasks the opposite happens. MoAI confirmed with data that using the expensive model more often actually shrinks the bill, and on top of that defined a three-tier assignment rule by task type.”

Here, the agent (an AI helper that works and judges on its own) and the effort (reasoning depth — the five levels low → medium → high → xhigh → max that decide how deeply the model thinks for one answer) are the two axes that decide cost. This page covers why these two axes are assigned the way they are, why Haiku was removed entirely, and why these “tiers” are a different concept from the autonomy grade.

Where intuition and reality diverge

The common assumption goes like this: “Run the cheap per-token models (say Sonnet · Haiku) in the busy seats, save the expensive model (Opus) for the important seats only, and the total cost will drop.” Looking at the token (the billing unit in which the model reads and writes text) price table alone, the assumption looks right.

But the assumption needs one premise to hold — that a weaker model still finishes the same task in the same number of steps. On a long-horizon agentic task (one that calls tools repeatedly, revises its own plan, and ends only when it sees the end), the premise collapses. The weaker model fails to converge, and as it fails it spins more steps and emits more output tokens without finishing. The per-token price is cheap, but the amount of tokens burned is far larger, so the per-task bill actually grows.

That is the starting point of this entire page. What sets the bill is not the unit price but completion efficiency.

flowchart TD
    A["Finish one agentic task"] --> B{"Is the model strong enough?"}
    B -- "Strong (Opus)" --> C["Converges in few steps"]
    C --> D["Few output tokens"]
    D --> E["Low cost per task"]
    B -- "Weak (Sonnet·Haiku)" --> F["Fails to converge"]
    F --> G["Burns even more steps and tokens"]
    G --> H["Higher cost per task"]
    E --> I["'cheap model = cheap bill'\nthe proposition flips"]
    H --> I

What the data says — the DeepSWE leaderboard

The source that confirmed the intuition above is the “All effort levels” view of the DeepSWE leaderboard (113 tasks / 91 repos / 5 languages, mini-swe-agent harness). Because effort is reported per level, the tiers can be derived from the shape of each model’s cost/score curve, not from a single operating point.

ModeleffortScore$/taskOutput tokensSteps
Opus 5low58%$1.6620k36
Opus 5medium69%$3.2937k52
Opus 5high73%$6.0864k73
Opus 5xhigh73%$9.0792k89
Opus 5max74%$11.84118k99
Sonnet 5low31%$2.1936k77
Sonnet 5medium40%$4.0857k108
Sonnet 5high48%$7.4387k147
Sonnet 5xhigh50%$11.89121k186
Sonnet 5max54%$26.40214k268
Fable 5high69%$9.1857k59
Fable 5max70%$21.63119k88

List price per MTok (in/out): Opus 5 $5/$25 · Sonnet 5 $2/$10 (introductory, through 2026-08-31, then $3/$15) · Fable 5 $10/$50.

Every figure in this table was measured on Opus 5. Opus 5.5, which the opus alias now resolves to, has not been re-measured yet.

Price inversion: Sonnet’s per-token price is lower than Opus’s, yet at every comparable point its per-task cost is higher — Opus 5 at low gets 58% for $1.66, while Sonnet 5 at max gets 54% for $26.40. The conventional wisdom “running a cheap model saves quota” does not hold on long-horizon agentic work, because what sets the bill is completion efficiency, not unit price.

Four conclusions read from the data:

  1. Opus 5 Pareto-dominates Sonnet 5 at every effort. Opus low (58%, $1.66) leads all five Sonnet points on both axes — score and cost — and Sonnet max (54%, $26.40) is no exception. The routing thesis “send the busy agents to the cheap model” is falsified on long-horizon agentic work.
  2. The cause is completion efficiency, not unit price. Sonnet spends roughly 2.7× the steps to finish the same task set. What makes the task expensive is not the per-token rate but those extra steps and output tokens.
  3. xhigh is a net loss on Opus. high and xhigh both score 73%, but xhigh costs 49% more and takes 22% more steps. Fable’s ceiling flattens at the same spot. Effort past the knee buys tokens, not points.
  4. medium is the knee. Marginal cost per point of score: low → medium $0.15, medium → high $0.70 (4.7×), xhigh → max $2.77 (18.6×). That is why the default profile anchors the core implementation agent at medium.

Why Haiku is removed entirely

Even Sonnet costs more per task than Opus on long-horizon work. Haiku is weaker than Sonnet. So adding Haiku to routing adds no capability — only step waste; the completion-failure pattern already observed on Sonnet would appear even more steeply on Haiku.

That is why MoAI excludes Haiku from the routing model set entirely (the No-Haiku policy, SPEC-AGENT-ARCH-V2-001 §D). Haiku remains a valid value in the model enum, so it appears in docs and example YAML, but it enters no combination of the session model lineup. Remove Haiku and the cost-cutting axis still remains — tiering effort (reasoning depth) per step instead of switching model classes. That is the starting point of the 3-tier structure.

The 3-tier assignment rule

The remaining models (Opus, Sonnet) and effort are assigned across three tiers by the character of the work. “Tier” here means a step of model·effort assignment keyed to task type.

The assignment tables from this section on are design intent, and the actual rule up to v3.1 (the per-agent profile-matrix era). From v3.2 the implemented behavior is session inheritance, so read this assignment as a record of the model-choice standards, not as current behavior. The split between the two is stated in “Reading design intent and implemented behavior apart” below.

flowchart TD
    START["A task arrives at an agent"] --> Q{"What does the row do?"}
    Q -- "Mechanical processing or\nread-only search" --> T1
    Q -- "It produces something" --> T2
    Q -- "It judges what others produced,\nor coordinates several rows" --> T3

    T1["Tier 1 — Mechanical & search
Sonnet low
manager-docs · manager-git · Explore"] T2["Tier 2 — Produce
Opus, a different step per row
manager-spec · manager-develop
builder-harness · e2e-tester"] T3["Tier 3 — Judge & coordinate
Opus, mostly high
plan-auditor · sync-auditor · manager-design
manager-lead · super-advisor · manager-todo"] T1 --> NOTE["Fixed across all three profiles"] T2 --> NOTE2["Two rows stay at medium in all three columns
only two step down with the profile"] T3 --> NOTE3["super-advisor · manager-todo hold high
even in the economical column"]

Work that follows a fixed procedure, or only reads and stops. Input rather than repetition drives the cost, and the thing that makes weaker models expensive — multi-step completion failure — never appears here. So Sonnet’s low input price becomes the operative factor, and low effort keeps the step count minimal. Agents on duty: manager-docs (documentation assembly), manager-git (commit and PR mechanics), Explore (read-only search). All three are fixed at sonnet / low across the three profiles (economical · default · quality) — raising the profile does not raise their model class.

Tier 2 — Produce

Writing the spec, implementing the code, generating a harness, running E2E scenarios — the rows that make something. They are multi-turn, so completion efficiency decides the bill, and Opus at low already outscores Sonnet at any effort while costing less per task, so Opus carries them by default.

The profile does not move these four rows alike. It differs per row.

RowQuality columnDefault columnEconomical column
manager-specopus / mediumopus / mediumopus / medium
manager-developopus / mediumopus / mediumopus / medium
builder-harnessopus / highopus / mediumopus / low
e2e-testeropus / mediumopus / lowsonnet / low

The authoring and implementing rows — manager-spec and manager-develop — stay at medium in all three columns, because not pushing spend toward production is this matrix’s decision. builder-harness is the only row that walks the full three steps, and e2e-tester drops its model to Sonnet in the economical column.

Tier 3 — Judge & coordinate

Seats that judge what others produced, or coordinate several rows. The matrix’s principle sits here in one line — spend goes to the rows that judge, not the rows that produce — because one judgment steers much of the downstream cost.

RowQuality columnDefault columnEconomical column
plan-auditor · sync-auditoropus / highopus / highopus / medium
manager-design · manager-leadopus / highopus / highopus / medium
super-advisor · manager-todoopus / highopus / highopus / high

Only super-advisor (the escalation path) and manager-todo (whose judgment sub-role is the sealed-mission verdict) hold high even in the economical column — those two are exactly what a cheap column most needs to keep sound.

The manager-todo judgment sub-role is what shows why this axis beats “multi-turn or not”. It reads once and returns a single decision, so by a multi-turn test it would belong on the Sonnet side; in fact it is opus / high in all three columns. Because it is a row that judges.

max is assigned to no row. It survives in the vocabulary as the only step above high, but the count of cells holding it is zero. xhigh is used nowhere either — on Opus it scores the same as high at 49% more cost.

Model tiers and autonomy tiers are different things

The “tier” on this page is an assignment step for which model at which reasoning depth goes to which work. The names are similar and easy to confuse, but MoAI has one other “tier.”

Info

Two tiers that share only a name

  • Model tier (this page) — fixes which model · effort each agent works with, by task type. Its subject is cost · quality.
  • Autonomy tier (MOAI_AUTONOMY_TIER) — the grade of how far an agent may act autonomously without human approval. Its subject is permission · control.

The two are orthogonal. An agent working on an expensive model at high effort (a high model tier) does not thereby get to act without human approval, and vice versa. The autonomy tier is handled by its own environment variable and 3-level mode selection — see the Autonomy Tier page for details.

Reading design intent and implemented behavior apart

An honesty distinction: this page keeps design-stage intent and actually implemented behavior clearly apart.

Design stage (.moai/reports/agent-architecture-redesign-v2-20260709.html) — the design intent of the v2 architecture. Presents the principles of the 3-tier model policy and the DeepSWE rationale.

Implemented behavior — since v3.2 the actual behavior is session inheritance. Subagents inherit the main session’s model and effort: pass neither model nor effort when spawning a subagent, and MoAI agent definitions declare neither. The former profile matrix (the 39-cell assignment table of 13 agents × 3 profiles) and the resolver that injected its values into spawns are retired. What the session model policy does today is set the session’s default effort fallback in moai profile setup — nothing more. See the Profile Matrix page for today’s behavior in detail.

Readers, too, should keep design intent (the DeepSWE rationale and the 3-tier assignment standards on this page) separate from implemented behavior (session inheritance).

What this benchmark does not measure

Limitation note: what this benchmark measures are coding agents. Documentation authoring, audit judgment, and SPEC (requirements document) authoring quality were not directly measured, so those row placements lean on the inference that they resemble multi-turn agentic work — they are not observations. Confidence intervals matter too: medium (69%±1) and high (73%±2) do not overlap, but max (74%±4) overlaps high. That is why max is assigned to no cell at all — it would be paying more for an overlapping interval. Every default is adjustable at the session level — the model by Claude Code’s model selection, the effort by /effort or the profile wizard’s session model policy.

On Fable 5: Fable loses on coding work across every effort. Fable high (69%, $9.18) delivers the same score as Opus medium (69%, $3.29) for nearly triple the cost. So it was placed in no matrix cell. It remains a valid value in the model enum, and the Fable-slot wiring of the GLM backend stays alive — only the defaults changed.

Connection to harness self-evolution

The 3-tier assignment is the foundation of the loop in which the harness improves itself. For the evolution loop — observation → reflection → promotion — to do its job, routing decisions in the observation phase must already go to the right model at the right effort. Mis-assigned routing contaminates the observations themselves, and contaminated observations produce wrong rules at the promotion stage. See the Harness Self-Evolution page for details.

Next steps

  • Profile Matrix — what replaced the 39-cell matrix, and today’s session-inheritance rule
  • Autonomy Tier — the permission · control autonomy grade, orthogonal to model tiers
  • Tokenomics Overview — the routing layer of the 4-layer tokenomics structure