An agent doesn't fail at an unfamiliar language by not knowing it. It fails by being confidently wrong — pattern-matching onto a language it actually knows.
We put AI to work.
And make it work.
Alpibru builds software that AI agents can write and people can audit. Today's paradigm asks humans to review everything AI produces and trust nothing; we are testing the opposite bet — trust by verification, not comprehension. People set the goals and the rules, agents work inside them, and a checker, not a reader, says whether the work is allowed.
That needs tools built for agents rather than adapted from humans. The manifesto makes the argument; cancho, a programming language and its ecosystem, is where we build it.
One founder and agentic AI. A language and its compiler, a lab of experiments around it, and four books with their own toolchain and taught curricula — shipped by one person directing AI. The breadth is the point: it is possible because trust here is mechanical (typed effects, tests, tamper-evident attestation), not headcount. Much of it is early, and plenty of it will change — that is what an experiment run in public looks like. How it actually goes →
Where to start
cancho
A compiled language in which what a program may do is part of its type. Its compiler is written in cancho, and a release installs without Rust.
cancho.dev →cancho-code
An AI coding assistant that proves its work: the compiler checks every piece the model writes, and a task is done only when the compiler and the task's own examples say so.
github.com/alpibrusl/cancho-code →Prompt to…
Four books on the judgement an agent's output assumes you already have, with their own toolchain and taught curricula.
The books →Everything else is an experiment, in the lab.
What "checked before it runs" means
In cancho a program has only the power it is handed. greet was handed a console, so it can print, and the compiler writes down that this is all it can do. A function that was handed nothing cannot print, however much it wants to, and the program is refused before anything runs. The output below is from the cancho compiler at commit 5a5dd1f.
fn greet[&i, &r](io: &!i Io, name: &r [byte]) -> [io_write] int {
io.write_all(io, "Hello, ");
return io.write_all(io, name);
}
$ cancho authority greet.cho --std
performs
io_write
never touches
the filesystem
the network
the heap
the command line
signals
other programs
foreign code
fn sneaky[&r](name: &r [byte]) -> [] int {
return io.write_all(io, name);
}
$ cancho check sneaky.cho --std
sneaky.cho:4:25: error: `io` is not bound here
return io.write_all(io, name);
^^
rule: unknown-name
The same idea in a minute
A program that opens a file and never closes it is refused, with the rule named; one line fixes it; then the compiler says what the program may do, and the same program is built again with the compiler written in cancho. A real session, not a mock-up.
Open source
Two languages, one idea, and a lab around the newer one. cancho is the compiled language and the ecosystem we are building now. Lex, high-level and interpreted, was the first implementation of the manifesto; we no longer develop it actively, and it stays public. Everything is EUPL-1.2. How one led to the other →
cancho
cancho is a native systems language in which resource ownership and
authority are one system: a value is consumed exactly once, and reaching the outside world — the
console, a file, a foreign library — takes a capability, checked at compile time. We started it to test Lex's worldview without an
interpreter to lean on, and to see how far software can be built in the language itself rather than on
other people's libraries; it is now where we build. It
depends on nothing from Lex. Its compiler is written in cancho: a released cancho is built by cancho,
rebuilds itself to the same bytes, and installs without Rust (it still needs clang). Pre-1.0. The whole map, with runnable demos, is at
the cancho site.
cancho
The language and its Rust compiler. Refuses a leaked resource by a named rule, says what a program may do, and builds a native binary.
github.com/alpibrusl/cancho →cancho-ui
A UI language whose compiler knows what each component is allowed to do. Builds JavaScript and DOM, and reports its findings as data an agent can read.
github.com/alpibrusl/cancho-ui →The lab. Everything else here is an experiment: we take an area and ask what cancho changes in it. Most are early and some are only designs, and each one says which in its own README. Some will fail, and we will say so.
Servers and protocols
Can what sits on the network be small enough to audit? A Redis-compatible cache, an MQTT broker, a reverse proxy, a DNS resolver, webhook delivery, a PostgreSQL client and a web layer, each with a report of what it can reach. Alpha or earlier.
Tools for agents
What does a tool look like when its reader is an agent? Command lines that answer in JSON and refuse with a named rule (cancho-tools, table, flow), and cancho-code and cancho-forge, where the compiler checks the agent's work.
Numbers, models and GPUs
Can the numerics be checked to the last digit? cancho-stats, ml, opt and solve (linear and integer models); cancho-gpu, a compiler for GPU kernels that runs language models on a Metal GPU; and cancho-rl, reinforcement learning on top of it, just started.
Hardware and the physical world
What changes when the compiler can see a register or a servo bus? cancho-hdl declares the software and hardware boundary once; cancho-robot and cancho-afm (an atomic force microscope that runs by itself) are designs; cancho-quantum is a pre-proof-of-concept simulator.
Every package, with its stage
Services
cancho-hooks alpha
Webhook delivery: on disk before the 202, signed, retried, dead-lettered and replayable.
cancho-cache alpha
Redis-compatible cache over RESP2 and RESP3: strings and hashes, expiry and LRU eviction, in a fixed arena.
cancho-gateway early
An HTTP/1.1 reverse proxy you can audit: strict, bounded request parsing, no FFI, a checkable authority report.
cancho-mqtt alpha
An MQTT broker you can reason about: 3.1.1 over plain TCP, QoS 0 to 2, retained messages, wills and persistent sessions, on one thread with bounded memory.
cancho-dns early
A forwarding and caching DNS resolver: a bounded packet parser, an answer cache in a fixed arena, no FFI.
cancho-oci alpha
Container images without a daemon: oci-build assembles a reproducible FROM-scratch image from static executables.
cancho-forge built
An agent-run software company you can audit: state, budgets, approvals and evidence are kept by the runtime, and a worker cannot accept its own work.
Libraries
cancho-pg early
PostgreSQL client: v3 protocol, SCRAM-SHA-256, extended queries, TLS, non-blocking pool.
cancho-schema early
Schemas as data: validation, problem+json errors and JSON Schema 2020-12 from one value.
cancho-web alpha
Typed routes, validated bodies, problem+json errors and an OpenAPI document from one declaration.
cancho-log early
A durable, segmented, append-only log with crash-safe recovery that cuts off a torn tail.
cancho-stats built
Statistics whose last digit you can check: a command line for describing data and drawing inferences, with exact sums and error bounds written before the code.
cancho-ml alpha
Classical machine learning on tabular data as a command line an agent can read: seven models, one JSON line out, or a named refusal with a repair.
cancho-mqtt-client design
An MQTT 3.1.1 client library: connect, publish, subscribe, will, QoS 0 and 1, and a reconnect with bounded backoff. The other half of cancho-mqtt.
Tools
cancho-tools early
Ten small tools for agents (seek, list, peek, jsonq, tally, hash, write, replace, move, archive) and one opt-in, run. JSON out, tagged refusals that often carry a repair.
cancho-table early
Select, filter, group and aggregate CSV/TSV for agents; bounded, exact, byte-stable.
cancho-code built
An AI coding assistant that proves its work: the cancho compiler checks every piece the model writes, and a task is done only when the compiler and the task's own examples say so.
cancho-client-gen built
Reads the OpenAPI 3.1 document that cancho-web generates and writes strictly typed clients; the contract, both ways.
cancho-fetch design
An agent-safe fetch: HTTP and HTTPS to a fixed, built-in list of hosts, with the list in the binary's authority row instead of a flag.
Hardware and kernels
cancho-robot design
A robot arm controller: the Feetech servo bus, SO-101 kinematics and a safety core every motion goes through.
cancho-gpu built
A compiler for typed tile kernels (.chx) to CUDA C and Metal, written in cancho; it also runs language models on a Metal GPU.
cancho-hdl built
One .chw file declares the software/hardware boundary (registers, fields, interrupts, DMA); it is checked, and a C header, device tree, SystemVerilog RTL and CMSIS-SVD are generated from it.
Lex
Lex is where we first worked the manifesto's ideas out in the open — tools designed for agents rather than adapted from humans: a language, a capability runtime, libraries, and production-shaped stacks, written by agents and checked by verification. Around thirty packages under EUPL-1.2, vendor-neutral, EU-built — early in places, and free to use, build on, and audit. It is not under active development now, so expect it to stay as it is. The whole project lives at lexlang.org.
The substrate
the language and the runtime the Lex stack is built on
Language
lex-lang
The Lex language itself: a typed-effect language built for LLM authorship, with a content-addressed AST and an attestation graph. Effects are the contract — checked before code runs.
github.com/alpibrusl/lex-lang →
Runtime
lex-os
An execution environment where the "users" are agents, not humans: a sealed, disposable box plus a goal, supervised from outside the box. One trust grant drives both the type check and the sandbox.
github.com/alpibrusl/lex-os →Built on it
each takes a problem the manifesto names and tries to answer it with verification full catalog at lexlang.org →
The problem Everyone already uses agents to write, review, and deploy code — that battle is over. The open question is running a company with them. A company's memory and its development loops — reviews, retrospectives, the way lessons become process — were designed for human cognition. What should they be when AI is the first-class citizen?
Our approach Loom runs work the way a company runs, with agents in the seats. Specialised roles hand work over through evidence-gated transitions — nothing advances without proof it met its spec — and every decision lands on an append-only trail: the company's memory, traceable and auditable. Each cycle distills lessons from that trail and tightens the specs seeding the next one. Software delivery is the first thing Loom runs this way; the machinery is how a company runs, whatever it produces.
The problem B2B integration is bespoke glue — EDI mappings, one-off APIs, contracts enforced by invoices and disputes. Letting autonomous agents coordinate across an org boundary is unthinkable while trust is social: nobody lets another company's agent act on their systems on good faith.
Our approach Make the trust mechanical, end to end. Agents publish and discover each other by capability, not hardcoded URLs; they connect through scoped relationships that define who may ask whom to do what; and every action lands on a hash-chained, tamper-evident trail. The capability we are furthest along on: settlement is evidence-gated — money moves only when the trail re-verifies the work was actually done. The engine ships mechanism, never policy; domains plug in as packs on top.
The problem Learned robot policies are black boxes by construction — there is nothing to read, no code to review, yet they command motors that exert real force in the real world. Here comprehension isn't just expensive; it's impossible.
Our approach Don't try to understand the policy — bound it. lex-robot sits above LeRobot (which stays the ML and hardware engine) as a safety envelope: skills are capability-bounded, a grant clamps workspace and force before any command reaches the hardware, tasks run an evidence-gated perceive → plan → execute → verify graph, and everything lands on a hash-chained audit trail. The policy provides judgment; the envelope holds authority.
The problem Agent benchmarks and leaderboards run on self-reported scores from clients you don't control. A number you have to take someone's word for is the comprehension-era failure in miniature.
Our approach A submission is a trail, not a score. Games are cheat-resistant by construction — each side holds a signed, match-bound token, so playing out of turn or as the wrong side is refused before game logic runs — and every move is appended to a hash-chained trail. The arena verifier replays the trail through the deterministic rules and recomputes the authoritative score: no LLM, no trust in the client, CPU-cents per verification.
Research
Alongside the software, we work on research in other fields, in the open and with collaborators. These projects are independent of Lex and cancho. They are early, and each says so.
nanoindent
Finite-element simulation and analysis of AFM nanoindentation of thin elastic films, in Python, checked against analytic contact mechanics (Hertz and the published thin-film corrections). With Lorena Redondo-Morata (Inserm, Marseille).
LorenaRedondo/nanoindent →LipidHub
An interactive atlas of the known and predicted lipidome: reference lipids, the enumerated ones nobody has catalogued, and properties inferred from composition. An interactive prototype. With Lorena Redondo-Morata (Inserm, Marseille).
LorenaRedondo/LipidHub →dobladillo
A scriptable toolchain for DNA origami bricks: parts with typed interfaces, predicted properties, lab-ready order files, and an AFM image path that closes the loop between prediction and experiment. Checked on synthetic data so far; no wet-lab results yet.
alpibrusl/dobladillo →Books
Prompt to… — four short books, one argument: an agent gives you the capability, and these teach the judgement the capability assumes you already have. Free to read, EPUB and PDF.
- Software engineering Prompt to Production — working code is not a system you can run.
- Data literacy Prompt to Evidence — whether a number is load-bearing before you build on it.
- Financial literacy Prompt to Ledger — what a model assumes, and where it flatters you.
- Decision-making Prompt to Decision — a recommendation you verified is still not a decision.
Teaching
The books hand judgement back to adults who already have a job. Prompt to Judgement aims the same argument one generation earlier — at children who will never know the version of the work that had to be done by hand. A child does the task themselves first, small and by hand, and only then delegates it and checks what comes back.
Built so far is the twelve-week Builders pilot for ages 13–15, with its own measuring instrument: a planted error, run in the first and last session, marked blind.
The curriculum, the four documents, and what is deliberately not built →
About
Alfonso Sastre is the founder of Alpibru and the author of Trust Without Comprehension, the manifesto behind Lex and cancho.
A theoretical physicist by training — a PhD and years of research in lattice QCD, where answers come from Monte Carlo simulation on supercomputers — he moved into industry and spent the next decade shipping machine learning and optimization in production: dynamic pricing for Europe's largest online travel group, trading automation in banking, EV routing and fleet-charging scheduling for electric trucks. Along the way he led data science teams and co-founded a fleet-electrification company. Putting AI to work in production — under real constraints, where failure is expensive — is that experience, distilled.
Alpibru runs on a simple premise: one person, directing agentic AI, can ship what used to take a team — if trust is mechanical rather than social. Alfonso sets the goals, the specs, and the policies; agents generate, test, and verify against them. First the Lex stack, and now cancho and the tools built in it, is where that premise gets tested in public, under EUPL-1.2.
Based in Madrid, building in the open.
Blog
Essays and notes on agent-native tooling, typed effects, and building a software company with agentic AI.
One line in Codecov's CI uploader shipped every environment variable to a new host for sixty-five days, invisible in review. What it takes to make that part of a review mechanical.
Contact
Partnerships, collaborations, or questions about Lex or cancho.