We put AI to work.
And make it work.

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.