Alpibru

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

Language

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 →
Tool

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 →
Books

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.

How authority reaches a cancho program main receives all authority once as a World value. split divides it into io, fs, heap, args and ffi. io is kept so the program can print, fs is narrowed to the directory /tmp, and heap, args and ffi are released unused. The compiler's authority report then lists exactly what the program may do and what it never touches. main(world) holds all authority, splits it once io fs heap args ffi kept, to print can write narrowed to /tmp can read there released, never used released, never used released, never used the compiler's authority report performs fs_read("/tmp") io_write never touches the network foreign code and the rest
The authority in the report is not declared by the author; it is derived from what the program was handed and what it did with it.
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.

From the manifesto to the cancho lab The manifesto states the idea. Lex was the first implementation: high-level, interpreted, no longer actively developed. cancho is the compiled successor with no runtime below and a compiler written in itself. Around it is the lab: servers, agent tools, numbers and GPUs, hardware. The manifestotrust by verification Lexfirst attempt · interpreted canchocompiled · built in itself The labexperiments by area
Language

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 →
Language

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
A glowing abstract syntax tree of sealed, content-addressed nodes 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 →
A sealed translucent cube containing a bright orb, watched by an external orbit ring 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 →
A pipeline of agent roles with evidence gates, threads braiding into a chain of memory

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.

Two organizations of glowing agents bridged across a boundary by a verified chain

lex-soft

agents that work across company boundaries github.com/alpibrusl/lex-soft →

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.

A robot arm operating inside a translucent safety dome, its moves recorded as a trail of blocks

lex-robot

agents with a physical body github.com/alpibrusl/lex-robot →

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.

A hash-chained trail of moves crossing a game board toward a prism that recomputes the score

lex-games

proving what an agent actually did github.com/alpibrusl/lex-games →

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.

Research · alpha

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 →
Research · alpha

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 →
Research · early

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.

All four books, the downloads, and how they are built →

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.

False Familiarity

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.

The Wall That Arrives Late

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.

alfonso@alpibru.com