Canery: A software factory that learns from what it ships
AI coding agents had made software far faster to write, but no faster to decide what was worth building or to learn whether it had worked. Teams were shipping more than ever with less idea of which changes mattered. To close that gap, I set out to build a software factory, not just an agentic coding tool: a system in which AI agents could find an opportunity, build a feature, measure how people used it and decide what to build next. The question was whether agents could understand the software they were building well enough to lead that cycle.
- Client
- Canery
- Deliverables
- Agentic Coding HarnessTelemetry SDKExperimentation EngineSignals Automation
- Year
- 2026
- Role
- Co-Founder, Product & Engineering
I engineered the harness at the centre of Canery from the ground up: a coding agent written in TypeScript on Bun and compiled to a single binary. Its agent loop streamed responses from Anthropic, OpenAI and OpenRouter models through one common interface, ran read-only tools in parallel and recovered cleanly from interruptions, truncated output and sessions that ended mid-task. I gave it 33 tools, from editing code and running commands to researching signals, managing documents and running experiments, and exposed them over MCP so other agents could use them too.
Much of the engineering went into keeping long sessions effective and affordable. The harness compacted its own context before it ran out, summarising the conversation and restoring the files it had been working on, and placed prompt-cache breakpoints so repeated context cost a fraction of the price. The desktop app drove each session as its own process over a headless streaming protocol, starting it only when needed and reclaiming it when idle. The same harness also ran as a cloud agent: for each job, the server launched a single-use container, so research could run overnight with no one at a desk.
Around the harness, I built the stages of the factory as tools the agent could use. Overnight, signals agents researched customer feedback, competitor moves and market data. Code rather than the model weighted each source by its authority and quality, and older evidence decayed over time, so the strongest opportunities rose to the top. Experiments tied each feature an agent built to a hypothesis and to the events that would confirm or refute it.
Telemetry completed the system. I built a lightweight SDK on OpenTelemetry that agents could embed in the code they wrote, with deterministic assignment of users to experiment variants and a pipeline into a statistics engine. Before an experiment could start, a dedicated tool checked that the agent had instrumented both the exposure and the conversion it was meant to measure.
That changed where an agent’s job ended. A coding agent usually stops when the code compiles and the tests pass. In Canery, the work was finished only when the agent knew whether the change had made a difference to the people using it. Shipping became the point where it started learning, and what it learned shaped the next thing it chose to build.