The 10-year vision

Software has always been limited by the number of people who can write it. Compilers, open source, and cloud each removed one bottleneck and grew the industry. Language models remove the last one: the human in the inner loop of writing code.

When code costs about what the compute costs, the amount of software grows sharply, most of it written and maintained by agents and never read by a person. Those programs still need somewhere to run: repos, models, GPUs, deploys, budgets, and review gates. Writing code stops being the scarce part; the loop around it becomes the scarce part.

Developer infrastructure is several large markets: code hosting, CI, compute, GPU inference, model APIs, observability, and creative tools. Each was sized for human developers. Agents break that sizing in two ways.

First, agents multiply builders. One customer runs dozens of agents around the clock, each consuming repos, compute, model calls, and deploys. Usage grows with agent count, which grows with model capability.

Second, agents cross market boundaries. One task edits a repo, calls three models, renders an image, runs a GPU job, and ships a deploy. Spreading that over six vendors is friction, and agents route around friction.

We do not need to displace incumbents. We need to be where new, agent-first workloads land, because that spend grows fastest.

All of this is live and billing customers. Hosted repos with branch previews and PR review. Coding agents that branch, edit, run tests, and open pull requests. An OpenAI-compatible gateway across 20+ model providers under one key. GPU inference with scale-to-zero endpoints, fine-tuning, and container builds. App and site hosting with free HTTPS subdomains. Twelve editors for video, audio, image, vector, slides, sheets, docs, 3D, animation, and whiteboard, sharing one asset store and one credit balance.

We run our own products on it. app.nz/papers, readingtime.app.nz, helix.app.nz, and gpubrain.app.nz use the same repos, agents, gateway, and hosting we sell. When the platform breaks, our products break first.

The breadth is deliberate. No single surface wins on its own, but together they are the one thing nobody else sells: the whole loop on one account, on one prepaid balance an agent can be trusted to spend.

The stages overlap, and parts of stage three are in research now. Stage one earns the account. Stage two earns the margin, because a router that saves customers money on every request is one they keep using. Stage three earns the category.

Teams pin a model because switching is risky, overpay for reserved GPUs because spot is fiddly, and leave latency on the table because benchmarking is a chore. A router should make those calls per request instead.

The gateway already routes across 20+ providers behind lanes like app/auto, app/auto-code, and app/auto-fast. The next version is a learned router with about a millisecond to decide. It embeds the request, checks live price, latency, and health from every provider, and places the work on the best model and the cheapest capable GPU: serverless for a burst, a hosted pod for steady traffic, spot when the interruption math works.

Every request teaches the router. A better router wins more traffic on price and quality. More traffic buys better capacity pricing and more training signal. That loop is the margin.

Agents do not stop at pull requests. The customer who asks an agent to fix CI also asks it to cut a launch video, build a deck, retexture a 3D asset, and record a voiceover. Existing creative tools bolt AI onto file formats made for one person. Our editors treat the agent as a collaborator: every operation is a tool, every asset lives in shared storage, every render bills the same balance.

Twelve editors on one substrate beat twelve products, because agents chain them. A marketing agent that writes the copy, draws the diagrams, cuts the video, and ships the landing page needs each step to be an API call on one account.

Self-organizing software is one loop: telemetry, detection, proposal, proof, gated merge, deploy. The system notices its own regression, writes the fix, proves it with tests and benchmarks, and ships it through a review gate a person configured once. Ownership moves from who wrote the code to who set the goals and constraints.

Each part of the loop exists today: repos and PRs (proposal), CI and VisualBench (proof), auto-agents (detection), deploys with previews (shipping), budgets and permissions (governance). We run early versions on our own estate, where agents file and fix real issues on the platform that hosts them.

Three problems stand between here and that category: verification strong enough to trust, goals that stay stable over thousands of iterations, and review gates that still mean something when proposals arrive faster than people read them. These are platform problems, solved with better proof machinery and better gates as much as better models.

Today's agents are sprinters: spawn, task, PR, exit. The valuable ones will run for months. Watching a dependency tree for CVEs and patching them. Holding a service's p99 under target by moving its infrastructure nightly. Running a storefront's content pipeline end to end.

A long-running agent is a customer that never sleeps and rarely churns. It is also the hardest workload to host. It needs persistent memory, resumable execution, spend limits, visible behaviour, and an owner who can always pull the cord. Each of those is a product. Schedulers, auto-agents, and queues are live now; memory and escalation are next.

We are a small, technical, founder-led team in New Zealand. We have shipped a lot of surface area because we build with the product we sell: the agents write the platform, and the platform hosts the agents. That is our development speed, our best demo, and the proof the thesis works.

We build in the open: public repos, public docs, public benchmark methodology. Every claim here is one demo away from being checked, and being checkable earns trust faster than a better deck.

We are capital-efficient by design. The routing we sell also runs our own fleet. Scale-to-zero keeps idle surface close to free. Agents do work that would otherwise be hires.

• Agents are customers. Build every surface so an agent with a budget can operate it, and people get a better product too.
• The loop is the moat. Any single feature can be copied. The whole loop on one account cannot be copied piece by piece.
• Routing is margin. Every decision the platform makes better than a person, on model, GPU, or timing, is margin that grows with traffic.
• Governance makes autonomy sellable. Budgets, gates, and audit trails are what let customers say yes.
• Build in the open. Checkable claims beat polished decks.

The technical deep dive covers architecture, security, economics, benchmarks, and a dated roadmap.