The Code Is No Longer the Product. The Agent Is.
A new paper argues the agent itself is now the software and code is just runtime scratch paper. Here's why that reframes every architecture decision your team makes this year.
Stop Shipping Code. Start Shipping Intent.
A quiet 15-page paper hit arXiv this month and said the thing every CTO has been feeling but nobody's wanted to put in a board deck: the source code is no longer the product. In "Agentic Software" (arXiv:2606.05608), Zhenfeng Cao argues that an AI agent doesn't use code — it is the software, and the code it writes is disposable scratch paper generated at runtime and thrown away. At Kuaray, here's our take: this isn't a hot take about vibe coding. It's a structural claim about where value lives, and most enterprise stacks are built on the wrong side of it.
TL;DR For The CTO Slack Channel
- For 50 years, software meant static code carrying pre-written decision logic. A human decided, encoded the decision, and shipped it.
- Agentic software flips it: the decision logic is generated at runtime by the model. The agent is the artifact, not the repo.
- The arc is Licensed → SaaS → Agent-as-a-Service (AaaS) — each step offloaded more complexity onto the vendor. AaaS offloads decision-making itself.
- New discipline name: Agentic Engineering. The engineer stops being a code author and becomes an intent architect.
- It's grounded, not hand-wavy: the paper leans on SWE-bench Verified, EvoClaw, and LangChain's multi-agent coordination studies — and is honest that the failure modes are still real.
Why This Isn't Just Vibe Coding With a PhD
The cynical read is "academic dresses up Cursor in a lab coat." Wrong map. The interesting move is the carrier-vs-author distinction. In your current systems, your if/else blocks, your business rules, your routing logic — that's frozen human judgment, audited and version-controlled. In an agentic system, that judgment is minted on demand by a model that may not produce the same answer twice.
That's thrilling for capability and terrifying for governance. The thing your compliance team signs off on — deterministic, reviewable code — is exactly the thing the new paradigm deletes. If your decision logic lives in a runtime no one can diff, "what does this system do?" stops having a static answer.
Three Moves For Your Roadmap This Quarter
1. Decide what is allowed to be generated at runtime. Not everything earns nondeterminism. Draw a hard line: payments, auth, anything regulated stays as audited static code. Let agents improvise on the messy, low-stakes 80% — triage, drafting, glue work.
2. Promote your seniors to intent architects — on purpose. The paper's "intent architect" isn't a vibe; it's a job rewrite. Your best engineers should be writing specs, evals, and guardrails, not racing the model to type a function. If they're still measured on lines shipped, you're optimizing for a role that's evaporating.
3. Build the eval harness before the agent. A system whose logic is generated at runtime can only be trusted through behavioral evals, not code review. SWE-bench Verified exists because "looks right" stopped being enough. Your internal version of it is now load-bearing infrastructure.
Schedule a Technical Architecture Review with our Strategists — we help engineering teams draw the line between what should be coded and what should be generated.