STIGMERA

Manifesto

The autonomous economy needs a factory

Agents already write the code. Almost nobody has made them responsible for the outcome. This is the argument for closing that gap — and for the way we think it closes.

The writing part is solved

The argument about whether AI can write production code is over, and it ended quietly. More than 80% of new production code at Anthropic is now written by Claude (VentureBeat). At Google, 75% of new code is AI-generated (Semafor). The person who coined “vibe coding” retired the term within a year and replaced it with “agentic engineering” (The New Stack) — a rename that tracks a real change: the interesting work moved from typing code to directing systems that type it.

So the bottleneck moved. It is not the writing any more.

The bottleneck is the loop, and it still runs on a person

Watch what actually happens after an agent finishes. It opens a pull request. A human reviews it, merges it, deploys it, waits, checks whether the number moved, decides what to try next, and writes the next task. The agent did the typing. The human did the thinking that made the typing worth anything.

That is why so many agent deployments quietly die. Gartner expects 40% of enterprise agent pilots to be scrapped by 2027 (forecast roundup). The usual explanation is model quality. We think the real one is simpler: a pilot with no metric attached to it cannot succeed or fail, so eventually somebody stops paying for it.

Every category on the map stops at the same place. Autonomous engineers — Devin, Codex, Claude Code, Cursor — stop at the pull request. App builders — Lovable, Bolt, v0 — stop when the project is handed to you. Goal-driven engineering tools stop at engineering outcomes inside a repository. Growth autopilots move one narrow surface and wait for approval. Declarative business goal in, full build-measure-iterate loop out: nobody sells that.

Make the metric the unit of work

Our answer is a change of unit. Not a task, not a prompt — a metric, with a baseline, a target and guardrails.

You set a business goal. Agents generate hypotheses, ship code, measure, and iterate until the metric is green.

Everything follows from that. If the unit of work is a metric, the system has to be able to measure — so the measurement instrument gets tested before the goal runs. If it can measure, it can be gamed — so every metric is paired with an antagonist metric that would suffer if the first were gamed. If it can be gamed, the referee cannot be a player — so an agent may propose a verdict on a hypothesis but never confirm one; the platform does that, from the numbers.

And because a loop like this touches production, it needs brakes that are structural rather than promised. Deploys stay on a manual trigger. Standards are enforced by tests in the pipeline. Goals carry budget caps. Autonomy is granted as a ladder — for a scope, with a mandate, revocable. We call it autonomy you can audit, and it is not a slogan: every step is a ticket you can read, every verdict cites numbers, every deploy files a report.

Why termites

Termites build cathedrals without an architect. No termite holds the plan; each one reacts to what the environment looks like right now and leaves a change behind. The next termite reacts to that. The structure comes from the traces, not from a manager. Biologists call it stigmergy, and it is where our name comes from — Stigmera = stigmergy + era.

This is not decoration on top of the architecture; it is the architecture. Our agents do not command each other. They read and write traces in a shared environment — tickets, branches, enforced standards, measurements, memory — and the system organises around what it finds there. The reason to build it this way is practical: direct coordination between many agents scales badly, and traces persist while conversations do not.

In August 2026 MIT put numbers on the same effect. In SwarmWorld, 50 to 200 language-model agents were placed in a shared environment, and roughly 95% of knowledge transfer between them happened through artifacts in that environment rather than direct messages (alphaXiv). Specialisation appeared on its own. We did not build the Factory because of that paper — but it is a pleasant thing to read when it describes your own system.

Where this ends up

The rails for autonomous software are being laid right now, and not by startups. Visa, Mastercard and Stripe have backed an open standard that lets AI agents pay autonomously (TechTimes). McKinsey projects $3–5 trillion in agentic commerce by 2030 (forecast roundup). Software that can be built, run and improved by agents will need to be discovered, bought and paid for by them too.

That distribution layer is where Stigmera Apps belongs — a storefront for autonomously built and operated software. To be clear about status: it is a vision, not a feature. It is not built, it is not sold, and it will not appear on a product page until it is real. The factory comes first, because a storefront with nothing on the shelves is not a business.

What we are not claiming

Two failure modes bracket this space, and being honest about them is the cheapest way to stay out of both.

Autonomy without measurement is AutoGPT: motion that feels like progress and produces nothing you can defend. Measurement without autonomy is a dashboard: an accurate picture of a problem that somebody still has to go and solve by hand. The interesting system is the one that holds both ends — and holding both ends is harder than either, which is why the loop is closing step by step rather than all at once. Delivery runs autonomously today. Closing the loop end-to-end on business goals is in progress. We ship it the way we ship everything else: in public, with the failures visible.

Sources

If you got this far

Come build with the factory

The Factory is in private access. Join the waitlist and we will write when it opens up.

We keep your email, plus the country and network address the request came from, so we know where interest comes from. Nothing else, nobody else — see Privacy.