Tool 02 · Architecture & run cost
Describe the workflow and its constraints in about ninety seconds. You get a real blueprint back: the orchestration pattern, the components we would and would not build, a model tier per role with the reason, and the envelope it runs in. No email, no gate, and every coefficient in the model is a slider you can move.
What this one can tell you
VelocityMind — Agent Architecture & Run-Cost Configurator · model sheet
prices as of 26 Jul 2026 — verify at source · rubric published in full at velocitymind.ai/tools/methodology
Logarithmic, because every interesting decision on this page lives between 10,000 and 100,000.
Distinct decisions or system touches in one run. The single most load-bearing input on the page: it sets the pattern, the token snowball, the serial latency and the end-to-end reliability.
Rendered live at your tokens-per-page assumption. Above 120,000 tokens the model stops sending the payload whole and switches you to retrieval.
Every coefficient that moves the answer is here, and every one of them is a slider. Change them and the blueprint, the envelope and the bill of materials all move with you.
Derived from the published ~0.75 words-per-token ratio, not a measured figure. Dense legal or academic text runs higher.
Your system prompt, tool schemas and few-shot examples cache. Your payload does not. At a 1.25x write and a 0.10x read, a cached prefix pays for itself after one read.
Multiplies every model call. Above 1.00 it also means some runs repeat a write — see the failure-mode dossier.
Zero passes means nothing independent checks the output. That is a legitimate choice; it is not a free one.
The probability one step is right. It compounds — which is the whole point of the reliability panel below.
Tool results ride the accumulated transcript, so this is one of the two terms the snowball is quadratic in. Published guidance caps tool output around 25,000 tokens before it is offloaded to a file.
Above zero this switches the latency model to the reasoning series — a different category, not an increment. The figures then read as end-to-end first-answer time including thinking, not time-to-first-token.
Deliberately the same default as the payback model, so the two tools cannot disagree with each other.
Gateway, vector store, tracing, eval runs, on-call.
Published list prices move monthly and ours will go stale. This re-runs the entire model against the prices you actually pay.
The per-MTok rates are the published figures; throughput and time-to-first-token are assumptions and move constantly. MID is set to the standard rate, not an introductory rate that reverts — a calculator hard-coding a promotional price is factually wrong five weeks after launch.
Several domains and a discovered path is the one case where a supervisor earns its complexity — and its token bill.
8 components in, 3 ruled out. Assisted — exceptions only — A wrong answer moves money, so the exceptions get a human and the rest do not.
Your p95 is over the latency budget you set. Send us the workflow behind this configuration and we will tell you which of these choices we would argue with — and which one would have killed it in production. One business day.
The identical workload, recomputed under the next-simpler pattern. Three signed figures, on your inputs — we are not quoting anyone’s percentage at you.
The accent thread is the critical serial path — 9 stages, and the only thing that sets your p95 of 99.9s. Dashed nodes are components we ruled out on your inputs; the reason for each is in the bill of materials.
| Component | In the build? | Model tier | Why | Tokens / run | $ / run |
|---|---|---|---|---|---|
| Planner | Yes | FRONTIER | Included: the pattern needs a plan before it delegates. Planning errors compound across every downstream step. | 16,330 | $0.103 |
| Router | Yes | SMALL | Included: the pattern dispatches to specialists, so something has to classify first. | 1,280 | $0.0018 |
| Specialist calls | Yes | SMALL | The work itself. The accumulated transcript lands here, which is why this row is quadratic in step count. | 175,640 | $0.210 |
| Retrieval over a curated corpus | No | — | Excluded: the payload is small enough to send whole. A vector store here is infrastructure you would maintain for nothing. | 0 | $0.0000 |
| Tool calling | Yes | — | Included: 1 system to touch, at 2 round trips each. | 1,200/call | in the specialist line |
| Working memory | Yes | — | Included: past three steps a run has state worth carrying, and carrying it explicitly is cheaper than re-deriving it. | +12% of context | in the specialist line |
| Long-term memory | No | — | Excluded: each run is independent. Cross-run memory here is a poisoning surface with no upside. | 0 | $0.0000 |
| Guardrails, in and out | Yes | SMALL | Included: input and output screening on a small model, plus a free deterministic schema check. A latency budget, not an intelligence budget. | 1,880 | $0.0025 |
| Evaluator | Yes | MID | Included: being wrong costs money here, so something independent has to check the output. It must be a different model family from the generator — an evaluator sharing the generator's failure modes rubber-stamps them. | priced as a fraction of a call | $0.127 |
| Human-in-the-loop queue | No | — | Excluded at this consequence level — but note that the review rate, not the model, is what sets your bill once it is on. | 0 | $0.0000 |
| Audit traillocked | Yes | — | Every architecture we ship has this. It is not an option. | 0 | build cost, not run cost |
| Deterministic fallback pathlocked | Yes | — | Every architecture we ship has this. It is not an option. | 0 | build cost, not run cost |
Human review is 54% of the monthly bill and model tokens are 37%. You came here to pick a cheaper model. On your own numbers, the model is not the bill — and review is the one line no price negotiation touches.
At 8 steps you are paying for 195K tokens per run against a naive 85K — a 2.3× understatement. Every step re-sends the accumulated transcript, so at twenty steps you are paying for the same context twenty times over. That is why the bill was never the price list.
S_prefix = SYS_BASE(900)
+ TOOL_SCHEMA(220 × 2 tools)
+ FEWSHOT(600)
+ TOOL_USE_OVERHEAD(350)
= 2,290
D_ctx = min(pages × A1, 120,000)
= 13,440 per call
O = 450 K = 1,200 Th = 0 N = 8
inputTokens = N × (S_prefix + D_ctx) + (O + K) × N(N−1)/2
└── the snowball: 46,200
outputTokens = N × (O + Th)
effectiveIn = (inputTokens − S_prefix×N)
+ S_prefix×N × [hit×0.1 + (1−hit)×1.25]
costRun = Σ roles [effectiveIn×rateIn + outTok×rateOut] / 1e6
× A3(1.15) × (1 + A4×frac) × A10(1.00)
× onprem(1.00) × batch(1.00)
= $0.445Sanity check on the published basis: S_prefix 3,000, D_ctx 4,000, O 600, K 1,200, N 10 gives 70,000 + 81,000 = 151,000 input tokens against a naive 70,000 — a 2.2× understatement before any other error.
Every term in that formula, labelled
As configured
At 95.0% per step across 8 serial steps, end-to-end is 66.3%.
What the target would cost
To reach 95% end-to-end you would need 99.36% per step.
At 95.0% per step across 8 serial steps, end-to-end is 66.3%. Nothing in the system is broken; the arithmetic simply multiplies down.
Mitigation
Move steps out of the model loop into deterministic code, and evaluate each remaining step independently rather than only the final answer.
The router sends an item to the wrong specialist. The specialist answers competently — about the wrong thing.
Mitigation
A confidence floor on the classification, a fallback route, and per-route accuracy in the eval harness.
The worker receives a task description rather than the full situation, and solves the description.
Mitigation
Explicit typed hand-off contracts, and a worker-level check that the task is answerable from what it was given.
A critic from the same model family shares the generator's blind spots and rubber-stamps them, which reads as high quality right up until it does not.
Mitigation
The evaluator is specified as a different model family from the generator, and is itself measured against the golden set.
Modelled p95 is 99.9s against a 30s budget. The lever is the serial path, not the model: collapse steps, run independent work in parallel, or move the whole thing off the interactive path and return a result asynchronously.
Human review is 54% of the monthly cost. No model price negotiation touches that line. Better routing and better evaluation are the only levers on it, and that is a build decision rather than a procurement one.
The same module renders the running tool and the published methodology page, so this disclosure cannot drift from the code that produced your answer.
steps ≤ 2 AND one domain AND consequence is not regulated AND the order of steps is fixed
steps ≤ 2 AND one domain
fixed order AND steps ≤ 6
interactive latency AND steps ≤ 6
domains ≥ 2 AND steps ≥ 4
(regulated OR a diagnosis or drafting workload) AND latency is not interactive AND runs ≤ 50,000/month
the selected pattern costs more than 3x the supervisor alternative (evaluated after costing)
First match wins. Rule 6 runs after costing: a pattern costing more than 3× the supervisor alternative is downgraded and we say so. Fan-out is withdrawn above 50,000 runs a month.
Each component is an independent boolean carrying its own trigger sentence — the bill of materials prints all eleven, in or out, with the reason. Audit trail and deterministic fallback are locked on.
The formula is printed in full in section 06 above, with your live figures substituted. Serial specialist call counts by pattern: single = N · pipeline = N (each stage narrower, context ×0.65, no transcript carried) · router = ⌈0.6N⌉ · supervisor = N with each worker re-reading the context · fan-out = 3 × ⌈N/2⌉ across parallel branches.
Review rate by derived oversight posture: advisory 100% · assisted, exceptions only 15% · autonomous with an audit sample 3% · autonomous 0%. You do not set this. It follows from the consequence of a wrong answer and the modelled end-to-end reliability.
per-call p50 = TTFT(tier) + (O + Th) / throughput(tier), summed along the serial path, plus 0.35s per retrieval hop and 1.0s per tool call across 2 round trips. p95 = p50 × 2.1, an assumption and an upper bound. End-to-end reliability = A5 ^ serial steps.
It has no benchmark, no peer cohort and no data about your organisation. It does not model build cost, change management, or the evaluation programme that actually decides whether any of this reaches production. It makes no model call of its own — every figure on this page is arithmetic you can reproduce.
The chain
This is the second question in a chain of four: should this be an agent? → what shape would it be? → does it pay back? → can you actually ship it? Each one can tell you not to do it. Back to the toolkit →