Build vs buy

What it costs to build this yourself.

> The expensive part is not the tokens — but one task is not one prompt either. It is a chain of roughly eight, each carrying thousands of tokens of edge-case instructions, one of them making tool calls against your tracker. Even so, the tokens are the cheapest part of building this.

$0Kengineering you don’t do
0.0xswing in your own token bill
0%accuracy in production
01 / Year one

One ledger, both totals.

~/strukt/year-one.ledgerusd

> build it yourself

build · 320 hrs × $106.59$0
edge cases · months of prompt tuning$0
maintain · 312 hrs / yr$0
llm tokens · chain × retries × trafficunbounded
year one · engineering alone$0

> buy strukt

plan · from $79 / mo, whole teamone line
edge cases · already solved$0
seats · any headcount$0
tokens · absorbed by strukt$0
overage · none at any volume$0
year one · everythingone flat line
02 / Edge cases

The line item nobody budgets.

$0K.

of edge-case prompt tuning — the biggest line in the ledger above, and the one nobody budgets for. It took us months of iteration on real channels before detection held up in production.

detection accuracy · production today0–0%
░░░░░░░░░░░░░░░░░░░░░░░░

> A clean prompt demos well in an afternoon. Every accuracy point after that is edge cases — and we are still not at 100%, which is why we publish the real number instead of promising one. How long it takes will differ for every team and every channel.

03 / Token cost

Every item runs the whole chain.

~8prompts per task
4–8kinstructions each
1 task filed or updated

> One task is not one prompt. Getting a reliable result takes a chain, and every link carries its own edge-case instructions.

> One of those links carries tools. Deciding whether this is a new task or an update to an existing one means searching your tracker. The tool definitions ride in the input on every call, and each result comes back into context — then the whole thread is re-sent on the next turn. The tools hog tokens as much as the prompts do, and this is the part people miss.

> None of it is deterministic. Some links run twice. And every call bills its full input and its reasoning tokens as output.

> Filing a task is the small half. Every update, comment, attachment, and recording runs the same chain, so 500 new tasks a month is really about 3,200 task items — and that is a modest month for a mid-size team, not a ceiling:

  • +500 new tasks filed — an 8-prompt chain each — the smallest line on this list
  • +2,000 comments and updates — 4 prompts each — keeping a task current costs twice what filing it did
  • +24,000 messages swept — a rolling 5-message window, because detecting work without commands means reading everything
  • +600 attachments — images and documents that have to be read before they can be filed
  • +80 meeting recordings — roughly 7k of transcript riding in context on every call
  • +15% corrected by hand — and run again — output is not deterministic

Every one of those calls re-sends three things, not one: about 6k of edge-case instructions, the message being processed, and roughly 8k of your company context — the glossary, the people, the projects, the prior decisions, the tracker schema — because the model remembers none of it between calls. That is ~23,000 calls and ≈ 355M input plus 18.5M output tokens a month. Reasoning bills as output at 5x the input rate. All of it scales straight up with volume: an enterprise running ten to a hundred times these numbers pays ten to a hundred times the bill — $537K to $5.4M a year on Claude Fable 5.

04 / Vendor rates

The same workload, three models.

OpenAI

GPT-5.6 Sol.

$4 in / $20 out · per 1M tokens
@ 3,200 items$1,789 / mo
@ 16,000 items$8,945 / mo
per task filed$3.58
year one$15,700 – $29,100
* promo rates through Nov 21, 2026
Anthropic

Claude Opus 5.

$5 in / $25 out · per 1M tokens
@ 3,200 items$2,237 / mo
@ 16,000 items$11,185 / mo
per task filed$4.47
year one$19,600 – $36,300
Anthropic

Claude Fable 5.

$10 in / $50 out · per 1M tokens
@ 3,200 items$4,473 / mo
@ 16,000 items$22,365 / mo
per task filed$8.95
year one$39,100 – $72,700

* short-context rates per 1M tokens, verified September 1, 2026. Year one is a range because the two things that set it — chain length and retry rate — are the two you cannot fix in advance: 7 prompts with no retries against 10 with 30% moves every bill here by 1.9x, before traffic changes at all. Monthly and per-task figures price the same 8-prompt chain on each model — Anthropic pricing · OpenAI pricing

05 / Avoidable spend

Three ways the bill gets bigger than it needs to be.

There is no honest per-employee figure for this. What it costs depends on request volume, context size, output length, retry rate, and model choice — so it has to be measured per request, not estimated per head. What can be stated is the shape of it.

  1. 01

    Untracked AI activity

    AI use that happens outside central attribution, governance, and cost control, so it never lands in a forecast. Microsoft and LinkedIn surveyed 31,000 knowledge workers across 31 countries: among those using AI at work, 78% bring their own tools and 52% are reluctant to admit using AI for their most important work.

    Unapproved use is not automatically company-paid token spend. Personal subscriptions, company SaaS seats, and API charges are different pools — count this only where the company is actually paying for the requests.

    Microsoft & LinkedIn, Work Trend IndexFinOps Foundation, SaaS token economics

  2. 02

    Failed or retried generations

    Tokens spent on responses that fail validation, omit a required task field, or have to be generated again. Model output is non-deterministic by default — identical inputs can differ even at temperature zero — and malformed JSON, missing fields, and schema violations are documented failure modes that developers have historically handled by simply retrying. One 2025 study across five models and eight tasks measured accuracy varying by up to 15% between repeated runs.

    Variability is not waste by itself. It becomes waste at the moment a result cannot be used and triggers another paid request.

    OpenAI, non-determinismOpenAI, structured outputsNIST AI 600-1

  3. 03

    Premium-model overuse

    Paying flagship rates for task-creation requests that a validated lower-cost model could complete. At list prices the gap for the same token volume is 5× from Claude Opus 5 down to Haiku 4.5, 10× from Claude Fable 5, and up to 20× on input tokens from OpenAI’s GPT‑5.6 Sol down to Luna. Most workloads do not need a frontier model at every step, and routing to a cheaper one is among the highest-impact optimisations available.

    “Validated” carries that sentence. RouteLLM reports a 3.66× cost reduction while retaining 95% of flagship benchmark quality — a benchmark result, not a promise for your workload. The cheaper model has to pass a task-creation eval on your own examples first.

    Ong et al., RouteLLM, ICLR 2025FinOps Foundation, token economicsOpenAI, model price comparisonAnthropic, API pricing

Strukt answers the third by construction: orchestrating this is our whole business, so the architecture is a cost we paid once instead of one you pay to rediscover. It takes the second off your invoice entirely — your line is the same whether a generation lands first time or fifth, and a retry is our cost, not yours. The first is not ours to fix. What your team does with AI outside this pipeline stays your question, which is exactly why it carries no number anywhere on this page.

06 / Why ours is cheap

The orchestration is the product.

> The figures above price what a first build actually does: reach for the most capable model, because that is the shortest route to something that works. The hard part is not paying for tokens — it is finding the architecture, the sweet spot. That is our entire business, so we did it once: we run the chain on cheaper models and still hold 90–95%. That is the whole reason the price can be what it is.

> And it is one price for the whole team, not a price per seat. Because it is fixed rather than per head, your cost per person falls as the team grows instead of rising. A per-seat tool has to beat a target that keeps moving away from it: every hire raises their bill and leaves ours where it was.

07 / The rest of the build

What the token bill doesn't include.

  • +Two-way integrations — auth, rate limits, schema drift, and webhook replay, times eight tools.
  • +Idempotency — a retry that files the same task twice is worse than a miss.
  • +Evaluation — without a regression suite you can't tell an improvement from a regression.
  • +Hosting and on-call — someone owns it when filing silently stops at 2am.
08 / Straight answers

Asked directly.

Is Strukt cheaper than calling Claude or GPT directly?

On the models a first build actually reaches for, by a wide margin. At 500 new tasks a month — about 3,200 task items once you count their updates, comments, attachments, and meetings — the token bill alone runs about $1,789 on GPT-5.6 Sol, $2,237 on Claude Opus 5, and $4,473 on Claude Fable 5, for tokens only. Two things make it that large. First, the unit is not the task, it is the item: filing is the small half, and every comment, attachment, and recording afterwards runs the same chain, on top of the 24,000 messages swept to find them in the first place. Second, each call in that chain re-sends three things rather than one — the edge-case instructions, the item itself, and your company context, because the model remembers none of it between calls. Reasoning then bills as output at five times the input rate. Cheaper tiers do cost less per token, which is exactly the orchestration point.

How much does Strukt save per year?

The part we can state without guessing is the engineering: about $196,000 in year one — 320 hours to build, roughly 1,200 hours of edge-case prompt tuning, and 312 hours of maintenance, at the San Jose mean wage. On top of that sits a token bill we deliberately do not total, because chain length, retry rate, and traffic set it and none of the three can be fixed in advance. We quote engineering rather than a single savings figure for a reason: $79 is the entry plan, not what every customer pays, so a headline saving would be quietly assuming which tier you land on. What holds on every tier is that the engineering does not happen and the invoice does not move with volume or headcount. And it is a model on stated assumptions, not a measured customer outcome — it assumes you would otherwise build this, and it excludes benefits, employer taxes, and overhead, so the true cost of building is higher.

Why is Strukt cheaper than the tokens alone?

Because orchestrating tasks is our whole business, so the expensive part is one we pay once. The cost that matters here is architectural — how to decompose the work into a chain, which steps genuinely need a frontier model and which can run on something cheaper, and how to hold accuracy while doing it. We spent months finding that, and it amortises across every customer. The figures on this page price what a first build actually does: reach for the most capable model, because that is the shortest route to something that works.

Do you charge per seat?

No. A plan covers the whole team on a connected channel, however many people are in it — there are no per-seat fees, and adding someone does not change the invoice. Because the price is fixed rather than per head, your cost per person falls as the team grows instead of rising. A per-seat tool has to beat that moving target, and its bill climbs with every hire while yours stays flat.

How accurate is the detection?

90–95% in daily production use — after months of prompt iteration on real channels, and still improving. We publish the real number rather than promise 100%, because the gap between a clean demo and production accuracy is exactly the tuning this page prices in. How long that takes will differ for every team and every channel.

Does Strukt bill by token usage?

No — and not per seat either. Strukt does not bill by LLM token consumption or by headcount. Plans cover connected team workflows, so your cost does not move when a channel gets busy or when the team grows, and provider price changes are ours to absorb rather than yours.

Why does predictable pricing matter if tokens are cheap?

Because both per-token and per-seat pricing move with things you do not set at the start of the quarter — how much your team talks, how much it attaches and records, and how many people you hire. A launch week or a noisy incident channel multiplies the invoice, and you cannot reasonably ask people to think about token cost while they work. Two numbers show the size of it. At one fixed volume, the same chain at 7 prompts with no retries against 10 prompts with 30% retries swings the annual bill 1.9x on every model we priced — that is $39,100 to $72,700 a year on Claude Fable 5 without the workload changing at all. Then add traffic: five times the volume is five times the bill. Your Strukt line does not move across any of that.

How do I work out what our own AI spend could avoid?

Per request, not per employee — there is no credible per-head average, because the answer moves with request volume, context size, output length, retry rate, and which model you picked. Log the team, use case, provider, model, input and output tokens, validation result, retry count, and a trace ID for every call, then add three things: what you pay for requests you cannot attribute to anyone, what you pay for attempts that failed or had to be repeated, and the premium you pay above the cheapest model that has actually passed an eval on your own examples. Deduplicate before you total it — one failed flagship request is a retry or a case of premium overuse, not both. Categories that overlap are the reason most of these estimates come out too high.

See plans →

One channel free. Every plan covers the whole team, with no per-seat or per-token billing.