If you have spent any time with a coding agent in the last year, you already know the sugar rush. You ask for a GitHub Actions workflow that runs Syft, fails the build on Trivy findings, and signs the image with Cosign keyless. The agent drafts the YAML, you paste a couple of secrets, and CI goes green before lunch. It feels like the old two-week supply-chain stand-up just collapsed into an afternoon, and for a moment it is tempting to declare the problem solved.
Look, the reality is that green CI is not the finish line it feels like. What you just built is scaffolding with better autocomplete — useful, encouraging, and nowhere near a release spine. The calendar time dropped, which is genuinely good news for teams that used to burn weeks on boilerplate. The bill did not disappear. It moved. It now shows up as seat fees, token meters, review loops that refuse to stay quiet, and the same N-product drift problem you had before the agents arrived. We see this pattern every week: the demo looks free, the production system still costs real engineering, and nobody wants to put that gap on a slide until procurement asks.
Agents amplify whatever sits underneath them. Stack agentic scaffolding on a weak release foundation and you do not get a finished system — you get a faster way to multiply forks, allowlist debt, and evidence that nobody can re-read six months later. So let’s talk honestly about what one release spine actually costs in 2026, classical DIY and LLM-enabled DIY alike, without pretending either path is free.
What one release spine actually is
A release spine is the evidence layer that proves what shipped. It is the immutable release manifest that acts as a single source of truth for version, artifacts, and pointers to evidence. It is an SBOM generated at build time from what you actually resolved, not from a hopeful inventory someone typed last quarter. It is a vulnerability scan wired to real fail gates instead of a log nobody reads. It is a signature — Cosign or equivalent — bound to the artifact. It is policy gates that re-read real evidence before promote. And it is a promote and verify path with approvals and integrity checks that still make sense months later when an auditor, a customer, or your future self asks what left the building.
It is not Artifactory. It is not a full AppSec IDE or PR platform. It is not a hardened-image catalog. Those are different jobs, and you should keep them if you need them. The spine is the glue that turns scanners into a system: one auditable unit that binds SBOM, scan, sign, and promote so the story of a release can be reconstructed without tribal knowledge. When teams confuse “we bought a scanner” with “we own a spine,” the calendar looks fine for a quarter and then the N-product tax arrives.
Classical DIY: days for green CI, months for a system
Public tutorials will get you Syft plus Trivy fail-on plus Cosign keyless green in GitHub Actions in days to about two weeks. Add SLSA-ish provenance and admission verify and you stretch another two to six weeks. That is the sugar-rush window, and agents compress it further. Production-grade work is where calendars hit roughly two to six-plus months: manifest as single source of truth, evidence layout you can re-read, gates that mean something under pressure, promote semantics that survive org chart changes, and multi-CI parity when half the org lives in Azure DevOps and the other half refuses to leave GitLab.
The engineering-effort numbers below are judgment ranges, not Fremen measurements. Assumptions: a mid-senior platform or DevSecOps engineer at about fifty to seventy-five percent focused time, an existing registry, one primary artifact type, and a person-month equal to four person-weeks. Disagree with the assumptions if you like — that is the point of stating them.
Estimates — engineering effort
| Scope | Lean: one CI, keyless Cosign, minimal gates | Full: multi-CI, real gates, promote, docs |
|---|---|---|
| One product | ~2–3.5 eng-months | ~4.5–9 eng-months |
| Steady-state | — | ~1–3 eng-months/year |
Getting something green is fast. Getting a release system is where the months go. That gap is the real cost story, and it was true before coding agents and it is still true after them. The agents change which line item absorbs the pain; they do not erase the need for someone who understands promote semantics and evidence layout.
Reuse after product one is real. Maybe half to seventy percent of the stand-up carries forward into product two. The rest does not vanish, because every product brings its own CI quirks, artifact types, and allowlist politics. A rough formula from the same judgment model: after the first spine, each additional product still costs on the order of 0.3–0.5× the first stand-up. Scale the classical estimates across nine products with shared libraries and you land roughly ~7–18 eng-months lean or ~15–45 eng-months full. Those are wide ranges because part-time calendar stretches, and because “shared library” often means “shared until the second team forks it.”
Open tools are free. The engineering is not.
Syft, Trivy, and Cosign / Sigstore are $0 on the license line. The true cost is engineering, CI compute, storage, and the quiet ongoing work of allowlist ops. Commercial stacks that partially overlap still leave spine design on you. Public list and starting-at signals as of September 2026 — re-check live pages before you paste them into a procurement deck:
Snyk runs Free; Team from $25/mo; Enterprise is contact sales. Strong AppSec. Not your manifest single source of truth or Cosign multi-CI control plane. Chainguard Catalog starts from $19K for a team of 10 — hardened their images, not your app release orchestration. JFrog SaaS Enterprise X from roughly $950/mo and self-hosted Pro X from roughly $27K/yr — those pages are often JS-gated, so treat the numbers as directional. Registry and platform weight. Different packaging than a lightweight release-evidence CLI.
None of that is an insult to those products. It is a category reminder. Buying a scanner or a registry is not the same as owning the glue that binds SBOM, scan, sign, and promote into one auditable unit. We see teams buy the scanner, declare victory, and then spend the next year rediscovering why promote still needs a person who can explain the evidence path.
LLM-enabled DIY: seats, tokens, context tax, and rework
Agents compress boilerplate. They do not delete five other costs that show up the moment you leave the demo.
Seat and plan fees for Copilot, Cursor, Claude Code, and friends. Metered usage once included credits burn. Context tax — published analyses put roughly sixty to eighty percent of agent tokens on reads and navigation, not final writes, which means you are paying for the agent to wander your repo before it writes the one workflow you actually wanted. Rework loops: wrong severity gates, CI quirks across vendors, Cosign keyless versus long-lived keys, evidence path drift that only appears when someone tries to verify last quarter’s release. And human review. Promote and policy correctness still need a person who will put their name on the promote.
Public seat floors fetched September 2026: GitHub Copilot Free with limits, Pro $10/mo, Pro+ $39/mo, Max $100/mo with AI Credits for agent work. Cursor Pro $20/mo, Pro+ $60/mo, Ultra $200/mo, Teams $40/user/mo. Claude consumer Pro about $17–20/mo, Max from $100/mo. Cursor’s own docs guidance says daily agent users often land around $60–$100/mo total usage; power and multi-agent work $200+/mo. That is on top of, or consuming, plan pools — not a rounding error once you multiply seats across a platform team.
Estimates — token burn scenarios
Assumptions stated so you can disagree with them: one mid-senior engineer on agentic coding, not tab-complete only; about seventy percent input and thirty percent output; blended all-in rate roughly $6–$30 per million tokens, midpoint $12/MTok for illustrations. These are worked estimates, not Fremen telemetry.
| Scenario | Est. agent tokens, in+out | Token $ mid @ $12/MTok | Range @ $6–$30 |
|---|---|---|---|
| A. Lean greenfield — one GHA workflow, Syft+Trivy+Cosign keyless, light docs | 2–8 MTok | ~$24–$96; mid about $60 | ~$12–$240 |
| B. Production single-CI — manifest schema, evidence refs, real fail gates, doctor checks | 15–40 MTok | ~$180–$480; mid about $330 | ~$90–$1,200 |
| C. Full multi-CI + promote — GHA+ADO+GitLab parity, approvals, hardening | 40–120 MTok | ~$480–$1,440; mid about $960 | ~$240–$3,600 |
Add prorated seat during a two-to-six-week accelerated stand-up: roughly $50–$400 depending on plan. Small versus salary. Not small versus a fixed annual spine license once you multiply seats times products times rework.
Honest read: a single lean experiment can land in tens to low hundreds of dollars of tokens. That is cheaper than buying glue, and if your goal is learning, that is a fine use of money. A production spine, and especially a portfolio of them, is where seat plus token plus rework stacks while quality and drift risk remain. The agent did not delete the senior engineer’s judgment; it moved some of the typing into a meter you still pay.
Agents amplify foundations — they do not replace them
This is where the foundation problem lands hardest on release spines. Agents speed scaffolding. They do not ship an org-wide immutable single source of truth and verified gates by themselves. Nine LLM-built forks still means nine drift surfaces. Even if each product’s agent stand-up is only a few hundred to low thousands in tokens plus a share of seats, nine production or multi-CI spines can still burn on the order of about $5K–$30K+ in LLM variable cost over a program year, as a worked estimate. You still own allowlists, promote semantics, and auditor-ready evidence nine times.
We see teams treat the agent as a substitute for foundation work — paste the workflow, green the pipeline, move on — and then discover six months later that nobody can reconstruct what shipped, that severity gates disagree across products, and that the “shared” template has forked into three dialects. Strong basics turn AI into a force multiplier. Weak ones turn it into an expensive accelerator of the same mess you already had. The release spine is one of those basics. Skip it and the agents will happily help you skip it faster.
So the honest question is not “can an agent build a Syft-Trivy-Cosign workflow?” Of course it can. The honest question is whether you want to keep reinventing the glue per product while meters and seats accumulate, or whether you want a spine that already is the glue and lets your agents work on the parts of the product that are actually yours.
Soft close: buy the glue, keep the registry
ReleaseFlow, also called rflow, is the local-first CLI we built for that spine: immutable release manifests, Syft / Trivy / Cosign orchestration, evidence layout, and on Business the gates, verify, and promote path without a hosted control plane you babysit. Open-core covers manifests and orchestration. Business adds the gates and promote path. Business Edition list price is $2,500/year unlimited.
That is not a claim that Fremen measured your savings. It is a pricing bet against reinventing the same glue per product while agents move cost from calendar time into meters you still pay. If you need Artifactory, full Snyk, or a Chainguard catalog, keep those tools. If you need the spine that binds SBOM, scan, sign, and promote into one auditable unit, stop treating green CI as the finish line.
Get the foundation right before you scale the agents across every product. They will make scaffolding go up faster either way — the only question is whether the release system underneath can hold what you ship.
Engineering-month and token figures in this post are judgment ranges with stated assumptions, compiled September 2026. They are not Fremen Labs timesheet measurements or product telemetry. Seat and competitor prices are public list and starting-at signals as of that date. Re-check live pages before you quote them in a procurement deck. Blended token rates use public API cards weighted for agent-heavy read workloads; your mix will differ.
The supply chain threat landscape is not slowing down. Neither should the honesty of your cost model.
