One Founder, Thirty Experiments

I. The Receipt

The manifesto made an argument: that trust in software can be built on verification instead of comprehension, and that tools designed for agents — not adapted from human tools — are how you get there. An argument, however, is cheap. This post is about the receipt.

Alpibru is one person directing agentic AI. What exists today is the Lex stack: a typed-effect language, a capability runtime where agents operate sealed and supervised, libraries for the boring essentials — web, schemas, persistence, money, logging — and production-shaped systems on top, from a cross-org agent fabric to a bounded control layer for robots. Around thirty packages, open source, written almost entirely by agents, verified mechanically.

I want to be precise about what that proves and what it doesn't. It does not prove the stack is mature, that every package is good, or that the approach is settled. It proves something narrower and, I think, more interesting: that one person can now run an operation of this breadth — and that the breadth itself is not recklessness. It is the method.

II. This Is Trial and Error

Let me disarm the obvious reading early: this is not a victory lap. Alpibru is an experiment run in public, and most of what I do, day to day, is get things wrong at high speed.

Effect signatures start too broad and have to be narrowed. Specs turn out to under-constrain the thing that mattered. Agents produce plausible designs that verification refuses, and the refusal is the information. Whole packages exist because I wanted to know whether something was possible, not because a roadmap demanded them. Some of these experiments will die, and their death will be cheap — that is part of the design.

What makes this survivable is the substrate. When trust comes from verification, a wrong attempt cannot quietly rot the system: it fails a check, loudly, and the failure lands on an audit trail I can read after the fact. Trial and error has always been how engineering learns. What was missing was a way to afford enough trials.

III. Focus Was the Price of Expensive Engineering

Every founder learns the same catechism: focus. Pick one thing. Say no. And the advice was correct — for its era. When development is expensive, every idea you pursue is an idea you must staff, and every bet forecloses another. Focus was never a virtue in itself. It was a constraint imposed by the cost of building, dressed up as wisdom.

Look at what the constraint actually forced: you had to decide where to concentrate before you had the evidence to decide well. The most consequential choice in the company — which idea gets built — was made at the moment of maximum ignorance. Everything downstream, from sunk-cost bias to the ritual of the pivot, is the interest paid on that early guess.

This is the single biggest change in how I work compared to every team I have been part of. I do not choose one idea and defend the choice. I run several — the language demanded a runtime, the runtime suggested robots, the fabric suggested games and an arena to score them — and I let what we learn from each one redirect the others. The breadth of the Lex stack is not scope creep. It is a learning rate.

IV. Spreading the Bets

Running experiments in parallel is only cheap if three things hold, and all three come from treating agents as first-class citizens rather than fast humans.

Starting must be cheap. An agent working from a compact spec and a small formal grammar does not need weeks of onboarding into a codebase. A new package begins from a contract to satisfy, not a mental model to acquire.

Being wrong must be cheap. Typed effects and capability grants mean a failed experiment is contained by construction — it cannot exceed what it was allowed to touch. Killing it deletes a package, not a tangle of hidden dependencies.

Learning must transfer. This is the subtle one. In a human team, what an experiment taught you lives in the people who ran it. Here, every run leaves a trail — what was tried, what failed, what the checker refused — and the lessons get distilled into the specs and conventions the next experiment starts from. The knowledge compounds even when the experiment dies.

In the old economics you paid to build and prayed to learn. In this one, building is the cheap part — so you build to learn.

V. Conventions Are Scar Tissue

The clearest evidence that this is trial and error — and that the learning is real — is that our own rules keep changing. The discipline that governs Lex development today was not designed upfront; each rule is a scar from something that went wrong:

• Narrow effects, always. Because broad effect signatures were the first thing agents reached for, and every broad signature is a hole in the story the types tell.
• Repair, don't regenerate. Because throwing away a nearly-right implementation to generate a fresh one loses information; a structured error plus a targeted transform converges faster than a new roll of the dice.
• Refuse, don't downgrade. Because a system that silently weakens its guarantees under pressure — falling back to a less-safe mode to keep going — is worse than one that stops and says why.
• Examples are part of the contract. Because a pure function with worked examples in its signature is a regression test nobody had to remember to write.

None of these came from theory. They came from the trail. That is what "learning on the way" means when the way is recorded: the retrospective is not a meeting, it is a diff to the rules.

VI. What the Human Does

The honest description of my job now: I decide what is worth trying, I write down what "correct" means, and I judge what the machine cannot. Goals, constraints, taste. The agents generate, test, and verify against what I wrote — and when the results come back, the interesting work is mine again: reading what the trail says, deciding which experiment earned more investment, and rewriting the specs with what we learned.

I review constraints, not code. I spend attention where judgment matters — at the spec, the policy, the surprising failure — and I let verification carry the rest. It is the manifesto's division of labor, lived daily: humans set goals and bear responsibility; agents execute. What surprised me is how much of the role that remains is editorial. Running thirty experiments does not feel like engineering management. It feels like editing a very fast, very strange research group.

VII. Still a Wager

Everything here could be wrong. The stack is young, the conventions will change again, and some of the thirty experiments will not survive the year — if none died, I would not be running enough of them. The manifesto called the transition a valley between human tools used by AI and agent-native tools mature enough to rely on. We are in the valley. This post is a field report, not a summit photo.

But the mechanism holds. One person, spreading bets that used to require a company each, learning at a pace the old economics of engineering never allowed — because trust is mechanical and mistakes are contained and every attempt, failed or not, leaves knowledge behind. If the manifesto's wager was that the shape of the tool matters, this is the corollary I can already defend from experience:

Focus was the price of expensive engineering. We don't pay it anymore — we pay attention instead, and we spend it where the evidence points.

— Alfonso Sastre, July 25, 2026