We build software with AI agents every day; a lot of the code in our product was typed by one. So we believe the productivity boom. What we don't see is anyone getting less busy. The volume of code and pull requests is up sharply, review load climbs alongside it, and workloads aren't falling. Addy Osmani's 70% framing is the shorthand for why: AI gets you most of the way fast, and the last stretch (the edge cases, the security, the integration, the is this even the right thing) is as hard as it ever was. Probably harder, because now there's more of it.
It's tempting to say the bottleneck moved from writing code to reviewing it. But it was never really typing. The hard part of software was always judgment: deciding what to build, knowing whether the thing should exist at all. AI stripped the typing away and left the judgment standing alone, at several times the volume. You can see the shape of it in how agents fail; we review these failures weekly. One builds on a stale premise from an old doc, fluently and with confidence. Another nails the ticket and misses that the ticket was the wrong move. Neither is a typing mistake; they are judgment failures at machine speed. Judgment didn't get automated. It got outnumbered. And we are not writing from a safe distance: a stale premise got one of us fired from Google, and an unreconciled one helped sink the startup we both worked at before that. Both stories are below.
The question that got expensive
For years we measured the layer that mattered least. Lines of code, commits, and raw diffs were always vanity, and AI made them actively deceptive: GitClear's 2025 analysis finds duplicated blocks rising, churn climbing, and the share of moved or refactored code falling as AI adoption grows. More lines, less load-bearing code. The units AI did not cheapen sit higher up (stories closed, features shipped), because closing a story still takes the judgment a model can't fully do; AI widened the gap between the cheap units and the valuable ones.
The DORA four keys are a better animal, measuring the flow and stability of delivery rather than its raw volume, and abundance distorts even them: the 2025 DORA report found AI's effect on throughput finally turned positive while its effect on stability stayed negative, tied to rising change volume. DORA's 2026 ROI report finds the same thing from the finance side: the return on AI investment tracks the organizational system around the tools, not the tools themselves. Clear workflows and aligned teams pay off; tooling alone doesn't. AI is an amplifier. It scales whatever capability, or dysfunction, you already had.
Every layer of this stack, vanity proxy to flow metric, leaves the same question unanswered: toward what? You can ship more features, faster and more stably, and still be building the wrong things; at agent throughput the rework and wasted spend compound. Measuring volume without measuring aim tells you the amplifier is working without telling you what it's amplifying. So the question quietly changed underneath us. It is no longer how much did we ship? It is did we ship the right thing, and how would we know? No tool on the market answers that second question, and the reasons are more interesting than "nobody got around to it."
Everyone is building the inner loop
Run agents for a week and the work sorts itself into two loops. The agent's inner loop is the work itself: investigate, implement, test, report. The engineer's outer loop is what decides whether that work earns production trust: decide (is this worth doing at all?), verify (is the evidence enough?), approve (ship, block, or redirect), own (carry the consequence). The inner loop is capability. The outer loop is accountability. Osmani draws the same boundary: capability loops against agency loops. And every maturity ladder we've seen teams plot themselves on, editor assistant to autonomous pipeline to multi-agent factory, charts exactly one thing: the inner loop maturing. At every rung somebody is still deciding what the factory should make and checking that it made it, and the ladder never says how.
Dex Horthy, the author of 12-factor agents, draws the whole factory in one diagram, and it makes the omission visible. Vision, product managers, and engineers all feed a box labeled stuff to do; the box feeds orchestration, harnesses, and models; out come pull requests; monitoring, incidents, and complaints flow back into the same box. Everything downstream of the box is funded, crowded, and improving fast. The box itself, the thing that decides what the factory makes, is drawn as a box because nobody has opened it. His question, how much can you stuff into the queue?, is the right one, and the quieter implication points the other way: when execution gets cheap, the queue is where the value concentrates. What goes in, in what order, on what premise, and on whose authority is the part no harness executes for you.
The tooling on both sides confirms the blind spot. The metrics platforms (Jellyfish, Faros, Linear, LinearB, Planview: effort by initiative, allocation, Flow Distribution against strategy) have nailed the data half. The strategy half, the thing you'd trace execution back to, is a human tagging an issue or dragging a status to At risk. The strategy-to-delivery link is asserted, not computed: status theater, a confident green dot someone typed, sitting on a codebase that may have wandered somewhere else entirely. The OKR platforms (Jira Align, WorkBoard, Perdoo) are that failure at its purest: a tree of objectives joined to the repository by whoever remembered to tag an epic, graded by hand in a quarterly review. Gartner expects the metrics platforms to reach 60% of Fortune 500 companies by 2028, up from 15% today. The demand is arriving; the honest answer isn't. The agent-era startups miss the same layer from the other direction: every product downstream of Horthy's box treats the queue as an input someone else fills and the outer loop as a decision click. They will run whatever you queue; none of them can tell you whether the queue is coherent, whether a ticket still serves a live goal, or whether a human ever ratified the premise the agents are about to build on. The metrics vendors assert the link between execution and strategy. The agent vendors assume it. Nobody computes it.
The part we lived
That gap is not hypothetical to us. We lived it twice, at two companies, at two altitudes of the same graph. In the spring of 2026, Google fired Justin for shipping a command-line tool. He was nearly seven years in, on Workspace developer relations, where open-source layers over the product's APIs were the job. The Workspace CLI he built went to #1 on Hacker News and gained thousands of users within days, with directors asking what they could learn from it while legal asked why the logo was on the repository. Nobody else was building it, because the product's automation strategy was still aimed at the previous era of visual workflow builders; the demand only became visible because he shipped anyway. An official CLI got underway in response, and the premise that ended his run, that the work threatened the product, had already been superseded by the company's own new direction. Nothing forced the two into the open together. The stale premise stayed live long enough to fire him, two days after the company announced it agreed with him.
Before Google, both of us, Justin and Ashley, worked at Descartes Labs, the satellite-imagery company spun out of Los Alamos: eight figures of revenue and one unreconciled premise, known inside the company as the Descartes Labs Dialectic. Is this a software company or a high-end consulting company? The evidence kept answering consulting; the board's model, and the multiples it had paid, kept insisting SaaS. Two accounts of what the company was ran live side by side for years, nothing forced a supersession, and the gap was papered over with growth targets built on the premise the evidence had already rejected. It resolved the way unreconciled intent always resolves: the founding CEO fired in January 2020, and a company that had raised close to a hundred million dollars sold in a fire sale in 2022. Mark Johnson, that CEO, wrote the requiem himself; we recognized every page of it.
We tell these stories as signals, not grievances. In neither was the inner loop the problem: the tool worked and the users showed up; the science was real and so was the revenue. What failed, at a trillion-dollar company and a hundred-million-dollar startup alike, was the outer loop, decide and verify and own, running on premises nobody had reconciled. In both, a premise stayed live after the ground under it changed, because nothing existed to force the old account and the new one into the same room. The rest of this argument is about how to force that reconciliation before the bill arrives.
You can't answer it by pointing AI at AI
The intuitive fix, in 2026, is more AI: if agents write the code, have an agent check it against the goal. There's a structural problem with that. The model reviewing the code and the model that wrote it share a training distribution, and therefore share blind spots; the reviewer tends to like exactly the kinds of mistakes the author tends to make. As "The Specification as Quality Gate" puts it, the review ends up checking the code against itself, not against intent. Correlated failures don't cancel out; they compound. The loop framing finds the same circle from inside it: the boundary evidence (the diff, the tests, the logs, the why) is all produced by the inner loop. It can tell you what the agent did. It cannot tell you whether the work was worth doing, because that judgment needs a term the evidence doesn't contain: what you meant.
The only way out of the circle is a reference that lives outside the model, and outside the loop that produced the evidence: a statement of what the work is supposed to do, that the implementation can be checked against. Spec-driven development is the same realization arriving in the tooling; by 2026 spec-first workflows were common from AWS's Kiro to GitHub's Spec Kit. Strip away the tooling and the claim is pretty simple: to know whether AI-written work serves your intent, you need that intent recorded somewhere outside the system being checked, authored or at least ratified by a human. (That last clause, at least ratified, does more work than it appears to, and we'll come back to it.) The same logic pins down where the reference can live: not inside the model vendor whose output it checks, and not inside the factory whose queue it ranks. It has to be neutral, or it inherits the conflict it exists to resolve. We hold our own product to this argument. Its diff-versus-intent verdict comes from a model too, and on its own it would be circular; it counts because it checks against a reference a human ratified, stays overridable, and sits beside drift detectors that are deterministic, with no model in them at all. The reference breaks the circle, not the judge.
The formalism is thirty years old
"Does the implementation trace back to intent?" is one of the oldest questions in software engineering, and the research on it is unusually strong. It's called requirements traceability, and in 1994 Gotel and Finkelstein pointed out that the hardest and most valuable part is the pre-specification link: connecting informal stakeholder intent to the specs and code that realize it. A chain of mission, vision, strategy, goal, project, and ticket is precisely that structure, made explicit and typed. And traceability isn't hygiene; it predicts outcomes. In a controlled experiment, having it made maintenance tasks about 21% faster and produced roughly 60% more correct solutions (Mäder & Egyed).
The neighboring constructs are just as old. Goal-oriented requirements engineering decomposes goals through AND/OR refinement and propagates satisfaction from leaf evidence upward, so "is this goal actually being met?" is a computation, not a hand-set dot. The reflexion model maps the real system onto an intended one and surfaces convergence, divergence, and absence; let the gap accumulate and you get drift, measured. These constructs are not metaphors for the stories above; they are their formal names. Two accounts of one company running live side by side is a divergence. A premise that outlives its own supersession is drift. The constructs have been validated for thirty years. What was missing was never the theory. It was a cheap way to capture intent as structured data and compute against it. Even the modern measurement frameworks, DORA to SPACE to Flow, reduce to the same instruction: connect leaf-level activity to a top-level outcome. They describe this graph without building it.
What a real graph computes
If the chain from mission to ticket already exists as typed, linked artifacts, with embeddings on each node and a record of who or what moved every one, the things everyone else declares become things you compute:
- Coverage from real linkage. What share of merged engineering effort actually traces to live strategy, computed from links between PRs and artifacts, not from how diligently someone tagged a ticket. No status theater.
- Diff-versus-intent verdicts. Does this pull request genuinely serve the artifact it claims to? This is the external spec the circularity argument demands, and the outer loop's verify made computable.
- Drift, as a trend. Per-artifact distance from its parent and root over time: the coherence signal that says implementation has wandered away from intent. It takes the typed graph and the embeddings together.
- Goal health by propagation. Satisfaction labels flowing up from leaf evidence instead of a dot someone set. Goal status you can defend.
- The stuff-to-do box, ranked. Horthy's box stops being a label and becomes a query. What should the factory make next? is answered from live intent rather than a hand-ordered list. The signals that flow back (incidents, complaints, requests) land as typed artifacts in the same graph instead of silting up a backlog.
None of these are exotic: they're the decades-old constructs, finally cheap because the intent is structured data instead of a planning doc. And one structure covers both ends of the outer loop: the graph that ranks what to do next is the graph the shipped work is verified against. Decide and verify stop being two rituals and become two queries.
And it's two graphs, not one. The intent graph holds the declared work: what we meant, who ratified it, what it serves. The codebase is the other graph, and it already exists: symbols, commits, pull requests, incidents, the inner loop's whole exhaust. That's the two-graph model, and it's why the checks above are computations instead of surveys: each one maps the real graph onto the intended one, the reflexion model running live. It also means signals don't only arrive top-down from vision and users. We mine them out of the inner loop: commits that trace to no live ticket, a subsystem drifting away from the goal that owns it, code that has quietly outgrown its premise. Each lands in the intent graph as a typed signal for the outer loop to rule on.
When the AI writes the intent, too
There's a hole in the argument so far, and it's the important one. Agents don't only write code; through MCP and similar interfaces they create and edit the artifacts above execution: the goals, the specs, the very reference the whole scheme leans on. If an agent drafts the goal, writes the code to it, and a model from the same family checks the result, the circularity is back, one layer up. The way out isn't to ban AI from the intent graph. It's to stop defining the external reference as human-typed and define it as known-provenance and, where it matters, human-ratified: record who or what made every mutation at every layer, let agents propose changes upstream, and route judgment-heavy proposals through a human decision that is itself recorded, the outer loop's decide running one layer up. Today provenance is universal while the ratification gate is selective: a workspace can require ratification where it chooses to, and making that gate the enforced default across intent mutations is next, not shipped. Drafted by AI and ratified by a human still works as a quality gate; the target invariant is that unratified AI-authored intent cannot become an execution target.
That inversion also answers the objection every hand-maintained planning tree has earned: that the graph will rot into exactly the status theater it replaces. The old trees died because humans were the write-path, and upkeep lost to real work every week. Here agents are the write-path and humans are the ratify-path, so the graph gets fresher with agent adoption, not staler. And the write-back isn't a chore an agent might skip: the graph is where an agent gets its next task, so reading it and reporting back into it sit on the critical path of doing the work at all.
It also defines onboarding. The team does not begin with a blank graph or a workshop. After GitHub is connected, the team asks its existing Claude, Codex, or other MCP client to use the context it can already reach, such as repository documentation, issues, pull-request history, and decisions in the working session, to draft the initial graph through Helen's MCP tools. Helen then asks the team to ratify the material decisions and resolve contradictions, instead of asking humans to transcribe everything they know. Agents fill the graph; humans establish which premises are authoritative enough to govern execution.
AI also makes intent cheap to mass-produce, so the reference layer inherits the abundance problem that hit code: three people ask an agent to draft a PRD for the same feature and get three overlapping, subtly different specs; a week later an agent writes a fourth because it never found the first three. Ask us how we know. Intent that is unstructured, duplicated, and undated amplifies exactly the way an unstructured codebase does, and nobody has written the rubric for the agent-ready organization. A folder of documents can't help; competing specs coexist, and whichever one an agent happens to open becomes the de facto truth. A typed graph can: flag near-duplicates as they're created, mark supersession so there is always one live head, surface sibling conflicts as signals. The scarce act is no longer writing the spec. It's deciding which spec is the spec. And provenance makes the worst case visible: an artifact that is AI-authored, never ratified, and serving as the alignment target for AI-authored execution is a self-sealing loop with no human in it. The second-order question the AI era forces is not just did we ship the right thing but did a human ever decide it was?
The ledger of intent
Everything so far treats the graph as a snapshot. Its history is where it compounds. Because intent changes create append-only artifact versions, and evidence, check, and rating histories accumulate the same way, the graph is also a ledger of intent: what was decided, when, on what premise, by whom, and what superseded it. Decision dispositions and execution outcomes still update live state in place; emitting those as immutable events is the roadmap step that completes the ledger. That makes time a first-class query. Alignment verdicts become honest, checked against the intent that was live when the work shipped rather than against today's rewrite; anything else manufactures false drift in one direction and false alignment in the other. And the stale premise, the failure that ended Justin's run, becomes a computable class: a join between when a premise changed and what still descends from its old version.
For a buyer, the ledger reduces to two questions asked after every incident: what was believed to be true when this agent acted? and what do we know now that we did not know then? Those answers are what make historical evaluation fair, decisions replayable, stale premises detectable, and corrections retroactive without rewriting the original record. None of these ideas are exotic: W3C PROV has modeled entities, activities, agents, derivation chains, and delegated responsibility for over a decade, and OMG's DMN links decisions to their input data, knowledge sources, and executable rules. Helen's design lineage is deliberate about both, and honest about the boundary: today the ledger ships dated history and source-linked evidence inside the agent workflow; a standards-mapped, exportable decision-and-evidence trace with source anchors is the next step, not a shipped audit product. As PROV's own guidance notes, a provenance record is not inherently authoritative. The trust link is built separately, and that is roadmap work, named as such.
The ledger also defines a metric the industry doesn't have. DORA measures inner-loop flow, how fast code reaches production. The ledger measures the outer loop's analog: how fast an intent change propagates. Strategy edited Monday; by when were the goals, projects, and tickets underneath it reviewed, superseded, or re-ratified? Call it time-to-reconcile, the organization's coherence latency. Descartes Labs' time-to-reconcile on its central premise was, in the end, never; the market reconciled it instead. At human speed nobody could measure the number, and it rarely mattered until it did. At agent speed it is the difference between a factory aimed well and a factory aimed at last quarter.
The Monday morning
Put it together and you can draw the destination. Say it's a few years from now and you edit a strategy on a Monday morning. Nothing dramatic happens, which is the point. By lunch, every goal, project, and ticket that still descends from the old version carries a flag: premise superseded, review or re-ratify. Two tickets that quietly served the dead premise drop out of the work queue before any agent burns a token on them, because the queue is a query, not a list somebody grooms. An agent picks up the top item that afternoon. It doesn't rebuild its picture of your company from docs and chat and a stale README; it inherits one dated picture, the same picture every other loop runs against, current as of your morning edit. When its pull request lands, the verdict is checked against the intent that was live when the work shipped. And when someone asks, a quarter later, whether your Monday edit actually propagated, the answer is a number on a chart rather than a meeting.
Notice what nobody in this picture is doing. Nobody is dragging a status to At risk. Nobody is asserting, on a slide, that engineering effort traces to strategy; the share of merged work landing under live intent is computed from real links. Nobody is re-litigating a settled decision, because the decision is on the record with its date, its premise, and the human who ratified it. The governing question, did we ship the right thing, and how would we know?, has stopped being a quarterly ritual and become a property of the system: asked before the work by a ranking, asked after it by a verdict, both against the same graph. Little of this is speculative, and we won't oversell it either: most of these pieces already run on the workspace we build this company with, where more than three thousand pull requests have been checked against live intent so far, and some are still designs (the time-to-reconcile chart doesn't exist yet). The Monday morning is assembly, not invention.
This is Horthy's box, opened: what goes in, in what order, on what premise, and on whose authority, computed. And the humans have not been designed out. They have been put on the record: agents draft intent freely, duplicates get flagged at creation, supersession keeps one live head, and judgment-heavy changes land through recorded human decisions the graph remembers. The scarce human act has shifted from authoring intent to curating it, and the system is shaped around that fact. Nobody has written the rubric for the agent-ready organization; this is our draft of one.
And the ledger doesn't have to stay outside the factory. It's worth being precise about the phrase that comes next, because world model is not a synonym for memory. Memory retrieves what happened. An operational model represents what is true now, what ought to be true, who may change it, and what depends on it. That is what ships today, and the ledger is its state substrate: dated intent, execution evidence, authority, and objectives shared by every run. What compounds is the reconciliation record, and it is worth being exact about what Helen durably writes today: bitemporal intent revisions with ancestry; linked PRs attached to the artifacts they serve, with commit-pinned symbol provenance; verdicts and signals; and recorded proposal decisions. Those records are separate. There is no durable join yet from selection to execution to resolution. What the dispositions feed today is also specific: a detector precision history and recurrence suppression. Joining the records into one trace, and letting it improve queue rationales and drive a measured time-to-reconcile, is the next stage, not the shipped one. The moat is not that Helen may someday select models or schedule agents; it is that no other system observes software intent, execution, and human resolution together at this resolution. That record is materially harder to copy than a graph schema, and it is why today's reconciliation product compounds into tomorrow's planning system. That is the long game, and it gets more valuable with every agent added to the floor.
The guardrails are part of the design
The same research that motivates all this also constrains it. The default failure mode of any metric is Goodhart's law: the moment a number becomes a target, people optimize the number and lose the thing it measured. So the design carries its own discipline. Ship metrics in tension, never a single score. Suggest links rather than auto-writing them; a wrong link silently mis-attributes work, so surface the candidate and let a human confirm. Keep LLM judges overridable; they're swayed by phrasing, position, and verbosity, fine as a signal, never the last word. And the oldest warning of all, from the people who built the Balanced Scorecard: the linked map is the asset, and a scorecard that decays into a flat list of KPIs has already failed. The graph is the point; the numbers are secondary.
The market has noticed
None of this is a niche complaint. Mordor Intelligence sizes AI code tools at $9.35 billion in 2026, on the way to roughly $30 billion by 2031, growing about 26% a year, and the same report catches demand turning in exactly this essay's direction: enterprise buyers now ask for governance tooling and audit trails over raw model performance. Capital is following; Qodo raised $70 million in March 2026 for code verification alone.
The formation side is moving the same way. Stripe Atlas incorporated roughly 9,700 AI startups in 2025, 42% of its cohort and up from 15% two years earlier, with the share building agents specifically climbing year over year. Y Combinator's requests for startups sketch where that formation is headed: AI-native services in accounting, insurance, compliance, and healthcare administration. These companies are classified by their end market but operate, internally, as software factories. The requests name the missing primitive outright: a "company brain," structured and current organizational knowledge that agents can execute against. The need this essay describes is now explicit in investor formation theses.
Those verticals are not adjacent markets to someday pivot into; they are the same kernel with a different execution graph. The durable product is the reconciler between desired state and observed execution, and the invariant it runs on is general, with a human gate on both sides of execution: proposed intent, human ratification, delegated action, evidence and outcome, adjudication, and graph update. Code is the execution graph's first instantiation because GitHub makes agent actions unusually observable and their results verifiable. Strategy maps to ticket, ticket to pull request, pull request to symbol. Each vertical keeps the two sides paired: an AI-native insurance operator's intent graph holds risk appetite, underwriting rules, and authority while its execution graph holds quotes, policies, and claim decisions with their evidence; in compliance, control objectives and policy on one side, test runs, exceptions, and evidence on the other. Helen owns the temporal intent-and-authority ledger and the reconciliation kernel; each vertical adds an adapter pack for its events, evidence, outcomes, and controls: same kernel, new adapter, not a new ontology project per market. Each software-plus-AI company that formation wave produces supplies a new execution graph to reconcile against intent. That makes it an expansion path for this architecture rather than a crowd of lookalike startups.
To be clear about the boundary: any move past software is strictly post-PMF and customer-led. A proven AI-native insurance or compliance company is a prospective Helen customer with a different observable execution graph, not a business Helen launches or a cell it capitalizes. The kernel stays proven in the software loop, and software delivery stays the home base.
Verifying code is the first rung, and it's the crowded one. The layer this essay describes sits above it, and the open wedge is specific: startup-deployable, model-neutral reconciliation of known-provenance desired state against agent execution, at ticket-to-symbol resolution, inside the software loop: not is the code good? but is it the right work, and did a human ever ratify the premise? Every dollar into the factory raises the value of the layer that aims it, because the cost of aiming badly scales with throughput. We grow as code generation grows, and code generation is still climbing.
What the outer loop is worth
Ask an AI-native team what they pay for AI and the seat licenses are the small line: $32 a month for Cursor Teams billed annually ($40 monthly), low hundreds for a premium Claude seat. The number that grows is metered agent consumption, and in teams that run agents as a fleet it reaches four figures per engineer per month. A team paying that for the inner loop is buying volume, and volume without aim is exactly the waste this essay has been describing: tokens burned on a premise that was superseded last week, rework on tickets that should never have been queued, review hours on work nobody needed. Against that bill, the value hypothesis the current cohort exists to test is direct: one stale-premise PR caught before an agent builds on it should pay for the outer loop many times over.
So the outer loop is worth a fraction of the factory bill, and it scales with the factory rather than the headcount: a team of five running thirty agents needs more of it than a team of thirty running five. We start with software companies from seed to Series B with 5 to 100 engineers shipping 10+ agent PRs a day, where agent velocity has already made context and review an executive problem, and expand as their factory does.
The packaging is a monthly workspace minimum with credits included (Build at $20/mo with 2,000 credits, Grow at $200/mo with 20,000). Once usage billing starts, each credit past the included ones costs $0.01 on Build and $0.008 on Grow, 20% less than Build. What the durable meter should be is still a cohort question rather than a thesis claim: active repositories, linked work, or a hybrid, and how many credits each plan should include. Stale work prevented and proposals resolved remain value evidence rather than units we assume customers will accept on an invoice. The four-figure factory bill stays the value anchor: Helen prices as a fraction of the consumption it aims, not as a promise to allocate that spend. That fraction is what gives a CFO or founder, not just engineering, a reason to own the layer that keeps the factory pointed at the right work.
The team it takes
The system this thesis demands is really two systems, and the tension between them is the job. One half is deterministic: a typed, bitemporal graph, append-only intent history, detectors that are pure functions you can snapshot-test, correctness you can prove. The other half is stochastic: embeddings, drift findings, LLM judges that are calibrated rather than proven and never the last word. The guardrails above are not a compliance section; they are the engineering culture. Deterministic where truth must hold, stochastic where judgment pays, and a recorded human decision wherever the two disagree.
Scaling the company means hiring AI engineers who can hold both halves at once: people who can prove a graph migration correct, then calibrate a judge against a labeled set, and not treat the two as separate careers. They also have to be comfortable being the outer loop for their own fleet of agents, because that is how this product gets built; most of the code here is agent-written and ratified by the person who owns it. That profile is rare, which is partly what this document is for. If it reads like your kind of problem, the contact line below is not only for investors.
The bet
AI didn't make engineering measurement obsolete. It did something more specific: it made the cheap half (how much) nearly free and the expensive half (toward what) urgent. Answering it takes two things no current tool has together: an external reference for what you meant to build, with known provenance and a human who ratified it, and the ability to compute alignment against it instead of asserting it in a status update. Thirty years of requirements engineering says the constructs work. The AI-coding literature says the external reference is non-negotiable. The landscape says the layer is unclaimed.
So our bet is specific. The next thing isn't a better factory, a better harness, a better memory system, or a better model. The inner loop is already good enough, and it is getting better whether we work on it or not. The next thing is the outer loop: the stuff-to-do box made real, the deciding and verifying and owning wrapped around the factory, a harness for the humans rather than for the agents. The factories are funded. The queue is not.
Memory is the nearest miss on that list. Agent memory systems are well funded and genuinely useful, and recall is not the problem. Store three conflicting specs in a memory and you get three retrieval candidates, each fluently summarized; nothing in the store knows that two were superseded, or that nobody ever ratified the third. Whichever one surfaces becomes the premise. Memory can hand an agent the closest document it has. Only a reference with supersession and provenance can hand it the one that is still true.
The outer loop is messy and will never be entirely solved; that is the opportunity, not the objection. AI moved both sides of the equation at once: it made the question urgent, and it made the answer affordable. Teams brute-force it today, burning velocity and tokens re-deriving context, re-litigating settled decisions, reconciling every new spec against the pile. The blowup is worse than pairwise, because premises can be jointly inconsistent while every pair of them looks fine: with no canonical reference a conflict can hide in any combination of the pile. A canonical graph doesn't make that problem vanish, but it collapses the surface: each new item reconciles against the live heads it actually touches, and supersession keeps retiring the stale candidates that made the combinations explode.
The general version of this, a knowledge graph of everything an enterprise knows and intends, is hard and generic; the focused version is not: startups building software with AI, each assembling a factory and left to improvise the box that feeds it. Start there; earn the general problem later. The interesting product to build right now isn't a faster way to count what shipped, and it isn't a more autonomous factory. It's the loop around the factory: a way to answer, honestly and continuously, whether you picked the right things and whether you actually shipped them, and to show your work. Nothing forced our premises into the open. We're building the thing that would have.