AGS is the part of Infinite Haiku you look at: hundreds of workers over hours, every task an interval, every roll-up honest about being a roll-up, drawn on your GPU. We have been designing and building it by hand since April 2024. In the last week of September 2026 we rebuilt its engine for scale in three days, with AI agents doing the typing against a plan and acceptance tests we wrote. The three days were the short part. This post is about the two and a half years that made them possible, and what “done” meant.

The two and a half years

AGS, short for Area Graph on Steroids, drew its first shape on 21 April 2024: one flat colour, badly centred, and already the idea that makes IH different. Measurements over time become a shape you can fly through, not another line chart.

This was hand work, long before coding agents joined us, and most of the hard decisions were made that spring:

• Time that does not wobble. GPUs cannot do exact arithmetic on 64-bit timestamps. AGS keeps exact time on the CPU and sends camera-relative values to the GPU, so shapes stay crisp at any zoom.
• The browser as a first-class screen. WebGL 2 could not do what the design needed, so AGS went to WebGPU and Rust compiled to WebAssembly, in May 2024, long before that was a safe bet.
• Ask the GPU what is under the mouse. Selection is read back from the GPU, so finding what is under the mouse does not get slower as the picture gets denser.

What the next six weeks looked like, one problem at a time:

April 2024. Panning through time, fetching more data near the edge of what is loaded. The log under the picture is the data manager at work.

Labels drawn on the GPU, placed where the shapes are.

Selection read back from the GPU: as fast in a dense picture as in an empty one.

Metadata filters and relationships between elements, chosen from the first options menu.

None of this is pretty, and it was not meant to be. Each step settled one architectural question (exact time, data paging, GPU picking, the line between fetching and drawing) so that the next step could rely on it.

Then came the rest of the product around it: Kabuki, the web app, in June 2024; Poet, the datastore that lives in your infrastructure, from July; and on 7 February 2025, real Kubernetes metrics travelling from a cluster straight into AGS in the browser. That story is in our origin posts, starting with Teaching metrics to take shape.

The problem worth three days

By September 2026 the design was right and the drawing was not fast enough. For a quick prototype, part of the picture had been moved onto a general-purpose UI library that draws on the CPU. At the scale our customers care about, hundreds of workers over hours, it fell over.

We wrote down four rules for the rebuild, all of them older than the rebuild itself:

• Poet computes, AGS draws. Your Poet does the aggregation, the levels of detail and the layout, close to the data. The browser receives compact data and lets the GPU draw it. The UI library keeps only menus, legends and tooltips.
• Binary, all the way. A compact binary format on the wire. No JSON on the render path.
• Only what you can see. Poet sends the detail the current zoom needs and more only as you zoom in. Less memory in your browser, less CPU on your Poet, less egress on your network bill.
• Honest reduction. A bucket that was downsampled says so.

Why agents could go fast here

We are a small team, and we do not want venture capital to buy a big one. AI coding agents give us the hands. They do not give us the design: an agent rebuilding AGS without the last two and a half years would have built a fast version of the wrong thing.

We wrote the plan and a “done when” line for each of about sixty pieces of work. Nothing counted as done because an agent said so. It counted when it passed two acceptance tests that the agents did not write and could not bend:

• A scale test. 200 workers, five hours, 500,000 tasks, on two Poets, one of them killed and restarted during the run.
• A browser test. Real WebGPU pixels, in a real browser, over the real network path, against 28 written criteria.

Both were checked against a data generator that shares no code with Poet, so the product could not grade its own homework.

What “done” measured

The scale test passed all 20 of its criteria. The browser test passed 26 of 28, and we shipped v1 with the gap written down: the first overview over the direct peer-to-peer channel is still slower than our one-second target, because a cache that should keep it warm keeps the wrong entries. It is next on the list. We would rather tell you than draw you a nicer graph.

What the agents needed from us

Agents are fast and literal. The rules that made them useful are the same ones a good engineering lead gives people:

• Measure before you fix. Hold a small failing reproduction or a measured hypothesis before changing anything.
• Test the criteria, not only the code. A criterion that contradicts the product’s rules wastes a full run.
• Small first. A problem is reproduced on a small dataset in seconds; the full-size run is for the final check.
• Adversarial checks where silent errors hide: data, caches, replication and authorization.

The part no test could catch

The morning after v1, we opened AGS on a laptop and found that it had lost something. In the earlier renderer, the mouse wheel flew into the hierarchy: inner layers showed through the outer ones, faint from far away and sharper as you approached, like terrain seen from a plane. The rebuild was faster and correct, and it had quietly dropped that feeling, because no criterion asked for it.

Two short pieces of work brought it back, on the GPU this time: the wheel enters the band under the pointer, children fade in as you approach, and going back up is one key away.

That is the real lesson of the week. Tests measure what somebody wrote down. The feel of a tool comes from people who have lived with it since the first ugly frame. Agents gave us speed; the two and a half years gave us something worth building fast.

The same engine today: select a band and the others step back, its details open under the chart.

Infinite Haiku is built by a small, bootstrapped team with no investors to please: the first 1 billion nano-dollar company. (That is one dollar. We checked.)

Follow the build on this blog, or tell us about the workload you want to see and ask for a pilot.