The 10-Year Vision

For seventy years, the limiting factor on software was people who could write it. Every abstraction — compilers, open source, cloud, SaaS — was a lever on scarce human attention, and every one of those levers created a bigger industry than the one it disrupted. Language models are the last lever: they remove the human from the inner loop of writing code entirely.

When the marginal cost of producing software falls toward the cost of the compute that writes it, the volume of software explodes. Not tenfold — the way web pages exploded when publishing stopped requiring a printing press. Billions of programs, most written by agents, most maintained by agents, many with no human who has ever read the source.

That world does not need another IDE. It needs the thing every one of those programs must have: somewhere to live. Repos to version them, models to power them, GPUs to run them, deploys to serve them, budgets to constrain them, and review gates so humans stay in charge of what matters. The scarce asset stops being the ability to write code and becomes the loop around the code.

Developer infrastructure today is a set of enormous, separate markets: code hosting, CI/CD, cloud compute, GPU inference, model APIs, observability, and the creative-tools stack beside them. Each was sized by the number of human developers and human creators. Agents break that sizing assumption in both directions at once.

First, agents multiply the number of active builders. A single customer with one subscription runs dozens of concurrent agents, each consuming repos, compute, model calls, and deploys around the clock. Usage-based platforms are levered to agent count, not seat count — and agent count compounds with model capability, which is improving on a curve no human-headcount market has ever matched.

Second, agents collapse the boundaries between those markets. An agent doing one task touches a repo, calls three models, renders an image, runs a GPU job, and ships a deploy — in one session. Forcing that session across six vendors with six auth systems and six bills is friction that agents, unlike patient humans, simply route around. The integrated platform is not a convenience; it is what agent traffic structurally selects for.

We do not need to displace the incumbents to build a very large company here. We need to be where new, agent-first workloads land — and those workloads are the fastest-growing spend in software.

Everything in this section is live and billing customers now — not roadmap. Hosted repos with branch previews and PR review; autonomous coding agents that branch, edit, run tests, and open pull requests; an OpenAI-compatible gateway routing 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; and a full suite of AI-native editors — video, audio, image, vector, slides, sheets, docs, 3D, animation, whiteboard — sharing one asset store and one credit balance.

We dogfood relentlessly: papers.app.nz, readingtime.app.nz, helix.app.nz, and gpubrain.app.nz are real consumer and prosumer products built on the same repos, agents, gateway, and hosting we sell. When the platform breaks, our own products break first, and an agent usually files the fix.

This breadth is deliberate. Each surface alone has a bigger, better-funded competitor. Together they form the thing no competitor sells: the whole loop, on one account, priced in one prepaid balance that agents can be trusted to spend.

The eras overlap — pieces of era three are in research now — but the sequencing matters commercially. Era one earns the account. Era two earns the margin, because a router that saves customers money on every request is a router customers never leave. Era three earns the category: the platform where software runs itself.

Today, choosing infrastructure is a human job done badly. Teams pin a model because switching is scary, overpay for reserved GPUs because spot is fiddly, and leave latency on the table because benchmarking is a chore. Our position is that none of these decisions should be made by a person more than once — they should be made by a router, per request, forever.

The gateway already routes across 20+ providers behind lanes like app/auto, app/auto-code, and app/auto-fast. The decade version is a learned router operating within a roughly one-millisecond decision budget: embed the request, consult live price/latency/health telemetry from every provider, and place the work on the best model and the cheapest capable GPU — a serverless burst here, a hosted pod there, spot capacity when the interruption math works, across any provider we can reach. The same machinery moves long-running workloads: pods migrate to whichever cloud is cheapest tonight without the customer noticing anything but a smaller bill.

This is a flywheel disguised as a feature. Every request teaches the router; a smarter router wins more traffic on price and quality; more traffic buys better capacity economics and more training signal. Infrastructure arbitrage, compounding, sold as a one-line model name.

Software is no longer just code, and agents do not stop at pull requests. The same customer who asks an agent to fix CI asks it to cut a launch video, generate a slide deck, retexture a 3D asset, and master a voiceover. Legacy creative tools bolt AI onto file formats designed for humans working alone; we build editors where the agent is a first-class collaborator — every editor exposes its operations as tools, every asset lives in shared storage, every render bills the same balance.

Ten editors sharing one substrate beat ten point products, for the same reason the integrated loop beats six vendors: agents chain them. A run-forever marketing agent that writes the copy, draws the diagrams, cuts the video, and ships the landing page is only possible when every one of those actions is an API call on one account.

The endgame of agent-written software is not faster feature requests. It is software that maintains itself: systems that read their own logs and traces, notice degradation, file the issue, write the fix, prove it with tests and benchmarks, and merge it through a human-set review gate. Ownership shifts from "who wrote this code" to "who set this system's goals and constraints."

We are building toward this from both ends. From below: repos, CI repair, VisualBench screenshot review, schedulers, queues, and auto-agents are the organs such a system needs, and all exist on the platform today. From above: budgets, spend caps, permissions, and review gates are the governance layer that makes autonomy safe enough to sell. The gap between the two ends is the product roadmap for the back half of the decade.

Today's agents are sprinters: spawn, task, PR, terminate. The valuable ones will be marathoners — agents with durable memory, standing budgets, and escalation rules that operate for months. Watching a dependency tree for CVEs and patching them. Holding a service's p99 under target by renegotiating its infrastructure nightly. Running a storefront's content pipeline end to end. Growing a codebase the way a gardener grows a garden: continuously, incrementally, accountably.

Run-forever agents are the customer that never churns and never sleeps. They are also the hardest workload to host: they need persistent memory, resumable execution, spend governance, observable behavior, and an owner who can always pull the cord. Every one of those is an infrastructure product, and we are building each as a billable primitive — schedulers, auto-agents, and queues are the first three, live now.

We are a small, technical, founder-led team in New Zealand that has shipped an implausible surface area — because we build with the product we sell. The agents write the platform; the platform hosts the agents. That loop is our development velocity, our best sales demo, and our proof that the thesis works, all at once.

We operate in the open. Public repos, public docs, public benchmarks methodology, and this public investor room. Openness is partly conviction and partly strategy: in a market where every claim is a demo away from being checked, the vendor whose claims are all checkable compounds trust faster than the vendor with the better deck.

And we are capital-efficient by construction. Auto-optimizing infrastructure is not only the product — it is our own cost structure. We arbitrage the same GPU markets we sell, run scale-to-zero everywhere, and let agents do work that would otherwise be headcount.

• Agents are customers. Design every surface to be operated by an agent with a budget, and humans get a better product too.
• The loop is the moat. Any single feature can be copied; the integrated loop from intent to running system, on one account, cannot be copied piecemeal.
• Routing is compounding margin. Every decision the platform makes better than a human — model choice, GPU placement, spot timing — is margin that grows with traffic.
• Autonomy needs governance to be sellable. Budgets, gates, and audit trails are not compliance chores; they are the features that let customers say yes.
• Build in the open. Checkable claims beat polished decks. This document is the practice of that belief.

The next document, the technical deep dive, grounds every claim above in architecture, security, economics, benchmarks, and a dated roadmap.