Between 12 June and 18 July this year, four different teams shipped names for things already running in my practice. Vercel called one eve. Google called one the Open Knowledge Format. LangChain called one openwiki. The internet at large settled on “graph engineering”.
Shipped in autumn, named in winter. There’s a flattering version of this article, and I started writing it before I checked the dates.
The dates did not co-operate.
| What got named | Theirs | Mine | Verdict |
|---|---|---|---|
| eve — agent as a directory of files | 17 Jun | Sally on Hermes, 24 May (VAS-916/917) | Ahead by 24 days |
| OKF — markdown concept graph | 12 Jun | VAS-719, filed 5 May, still Queued | Beaten |
| openwiki — auto-maintained agent docs | 1 Jul | Built the manual version in April. Deleted it in July. | Wrong first |
| Graph engineering — stage contracts | 18 Jul | FortyTwo gates, VAS-1226, 16 Jul | Neither of us was first |
One win worth twenty-four days, one loss, one public failure, and one where the whole category turned out to be a joke. That’s the real scoreboard, and it’s a much more useful article than the one where I’m a genius.
Here’s the takeaway stated plainly, because it’s the only part that transfers: arriving first is worth nothing. Arriving at the same time as everyone else is the signal. Convergence doesn’t prove you were clever. It proves the constraint was real — and that is the only reliable way I know to tell a durable pattern from a fashionable one.
The twenty-four days
eve’s structure is an agent as a directory of files: instructions.md for the always-on prompt, skills/ for procedures loaded on demand, channels/ for Slack and the rest, schedules/ for recurring jobs.
Sally — my Telegram-resident agent — is a SOUL.md, a governed skill roster, a Telegram binding and five scheduled crons. VAS-916 and VAS-917 closed on 24 May. The digest formatter (VAS-652) was running from 4 May, and VAS-915 is an audit of the previous Sally, which already had skills and crons before the Hermes migration started.
So: twenty-four days. Not “months earlier”, which is what I’d written in my own capture ticket before I went and looked.
Twenty-four days is not foresight. It’s two rooms hitting the same wall in the same month. And I didn’t get there by insight either — I got there because every alternative was worse. Configuration in a database you can’t diff. Prompts buried in a dashboard. Behaviour you can’t inspect at 11pm when it’s misbehaving. Files won because files are legible. Vercel’s engineers evidently lost the same arguments with reality that I did.
The one I lost
VAS-719 has been sitting in my backlog since 5 May: turn the North Star document into a living spec — components, workflows, ADRs, all agent-legible. Google Cloud published OKF v0.1 on 12 June: markdown plus YAML frontmatter, one required field, concepts linked with ordinary markdown links so the directory reads as a graph.
That is my ticket. They shipped it in thirty-eight days. Mine has been open for eighty-eight and is still marked Queued.
Then they shipped v0.2 on 25 July, adding provenance and attestation — which tells you how fast “agents writing knowledge for other agents” went from a neat idea to a problem that needs signatures.
I’d like to claim this one as a convergence. It isn’t. It’s a demonstration that the distance between having the idea and having the artefact is the entire job, and that a backlog is where good ideas go to be right in private.
The one where I was wrong first
This is the beat I’d have cut from the flattering version.
openwiki is a CLI that writes and maintains agent-facing documentation for a codebase, refreshes it as the code changes, and ships a GitHub action that opens a pull request when the docs fall behind.
I built that. Badly. In April, the cross-project dashboard I later tore down rested on exactly this thesis: every repo carries a /docs/dashboard.md, the tool reads it, the cards stay meaningful. On day one in production, four of my five project cards read not yet documented — the thing faithfully reported the flaw in its own design before I’d finished admiring it. Manual capture was load-bearing, and I was never going to do manual capture.
Anyone who has watched an agent re-derive the same Linear team UUID across five separate sessions knew this tool was coming; that rediscovery tax is precisely why my linear-ops skill exists. The only real question was who would ship it first.
Same thesis, same month, near enough. The difference is that LangChain put the maintenance on the agent and the pull request on a CI action, and I put it on me. I ran the experiment and found the failure mode; they designed it out. Being early to a good idea and wrong about the hard part isn’t a receipt. It’s just being wrong with better timing.
The one that was a joke
On 18 July, Peter Steinberger posted a short question asking whether we were still talking about loops or had shifted to graphs yet. Two point nine million views later, “graph engineering” was a discipline.
It was a gag. So was Hamel Husain’s “loop engineering is dead” pile-on that followed it. Both were mocking the renaming treadmill — this industry’s habit of rebadging the same practice every few months. Prompt engineering, context engineering, harness engineering, loop engineering, graph engineering: five names, one job, about eighteen months.
The discourse reified the satire into a movement within days. Nobody shipped anything alongside the post. LangGraph, Google’s ADK and Microsoft’s Agent Framework had been wiring nodes, edges and shared state for two years already. The earliest serious use of the phrase I can find is a quiet Josh Simmons post on 4 July that nobody amplified. Within a fortnight the term had at least three incompatible definitions in circulation and a folk recipe — parallel subagents plus a checker, “graph-max” — attached to it.
I’d love to claim a dead heat here. I can’t, and neither can Steinberger. The shape is older than both of us; only the label is new, and the label was a punchline.
The durable idea inside the noise is narrower than the hashtag: build the contract before the work — what each stage must produce, and what has to validate before anything advances. That’s VAS-1226, closed 16 July: /42 refuses to bless an advance past a stage missing its artefact. It exists because I’d been burned by the opposite — a plan reviewed eight times, a green test suite, and an acceptance criterion that shipped unbuilt because nobody checked the deliverable against the checklist.
And one correction to my own instincts, courtesy of the sharpest critique in the pile: DAG schedulers are a decade old, and agents checking agents can produce organised nonsense at scale. A checker with fresh context is necessary but not sufficient, because a fresh-context agent is still inside the system. The evidence has to come from outside it — real tests, real money, real humans. What makes my gates worth anything isn’t that the checker has clean context; it’s that the gate is a literal label in Linear and the pass condition is provable from a transcript. External artefacts, not agent opinion.
There’s a footnote I can’t resist. Steinberger also built OpenClaw — the exact agent runtime I ran, cost-audited and migrated off months before he lit this particular fuse. Which brings me to the bill.
The bit the wave still gets wrong
Every pattern above makes it cheaper to run more agents: parallel workers, scheduled crons, wikis maintained overnight. Not one of them ships a spend ledger as the headline feature.
My receipt: OpenClaw’s idle heartbeat was re-warming roughly 270,000 tokens of cached context every half hour — about eight dollars a day for an agent doing nothing at all (VAS-870, 18 May). A week later, VAS-974: a runaway agent loop, with prompt caching silently broken underneath it, cache_read_input_tokens sitting at zero while I paid full freight on every turn. I only caught either because every model call in this stack routes through a gateway with a spend ledger and a key per workload.
Eight dollars a day is a rounding error, right up until you run ten agents in parallel because the new architecture made it easy.
The arithmetic that matters isn’t wall-clock, it’s cost per successful completion. Fan work out across stages and the win depends entirely on your subtask pass rate: around half, and parallelism wins comfortably. Down near a third, you burn the same number of cycles a loop would have at roughly triple the tokens per cycle — and you notice a month after the architecture decision that caused it, which is exactly too late to attribute. Run that sum against your own pass rate before you adopt anyone’s diagram.
One hygiene note, since this wave also produced a fabricated multi-million-dollar research study that circulated freely for days: before repeating any number from a thread like this one, ask what specifically was measured, improved compared to what, and where the figure came from. Mine are above with ticket numbers attached. Hold everyone else’s to the same standard, this article included.
The honest ending
Four teams landed the same shapes inside five weeks. None of us invented anything. We all just met the same wall — context is finite, plain files survive, and a stage that can’t prove it produced something shouldn’t be allowed to continue.
Adopt the shapes: files as the agent contract, markdown-with-frontmatter as the knowledge substrate, gates that check artefacts rather than vibes. Those converged independently, which is about as close to proof as this industry gets. Watch the brands: eve is a beta with moving APIs, OKF is at v0.2, and graph engineering was a joke that got its own courses and roadmaps. Adopting a shape costs nothing when the label churns. Adopting the label mostly buys you migration work.
The constraint is the evidence — not the author, and definitely not whoever got there twenty-four days earlier.