Back in April 2025, I wrote about what I was seeing from my seat at the CNCF. AI was catching on in the cloud native ecosystem, but it looked different from the hype. Platform teams were asking real questions at Kubecon EU 2025 about GPU scheduling, air-gapped LLM deployments, and multi-cluster orchestration. The front-end world had vibe coding, but infrastructure had unanswered questions.
I ended that newsletter by placing all my bets on the AI-enabled cloud-native era.
Then I went and did exactly that.
From Observer to Operator
My obligations to the role at the CNCF ended, and I immediately joined Continue, an AI coding tool company. Working there validated everything I had been sensing from the outside. The tooling for AI engineers was almost entirely TypeScript SDKs. The infrastructure story was an afterthought. If you wanted to run agents at scale, you were on your own or forced to use tools meant for frontend typescript environments.
Most AI developer tools were focused on the application layer. Build an agent, call an API with a key, get a response. Nobody was solving what happens when that agent runs for six hours inside your infrastructure. Nobody was building the observability layer. Nobody was thinking about audit trails, sandbox isolation, or what happens when something goes wrong at 2am with no replay.
When I joined Continue and we started building our cloud agent product, I ran into that same wall from the inside. Everything was still SDK and application layer driven. The infrastructure problem was not solved — it was just hidden under more abstraction. That gap is what led me to leave and start building Paper Compute.
The Paper Compute Company
Together with John McBride, we founded Paper Compute. John comes from the Linux Foundation and AWS (he worked on Bottlerocket, Amazon’s container-optimized OS). My background is GitHub and the CNCF, watching infrastructure evolve from the inside. We both saw the same thing: AI agents in production need dedicated infrastructure. Not another SDK. Not another wrapper. Real systems software.
We are building two open source projects.
Tapes is a telemetry layer for AI agents. It sits between the agent and the LLM as a reverse proxy, capturing every request and response without any code changes. No SDK. No instrumentation. It records at the network layer and stores sessions in a local SQLite database with hash-chained entries. You can query it, replay it, and feed past sessions into the next run. John wrote the technical introduction back in February.
stereOS is a hardened Linux distribution built specifically for agent workloads. It is based on NixOS with gVisor sandboxing. Each agent gets its own VM with its own kernel, memory, disk, and network. API keys go into tmpfs and never touch the host filesystem. When the agent is done, the environment tears down cleanly. The argument is simple: sandboxes are for experiments, agents need a computer.
Both projects are AGPL licensed and open source.
What We Built in Only 60 Days
The best way to prove infrastructure works is to run real workloads on it. So we did.
Pokemon Red. I built an autonomous agent that plays Pokemon Red inside a stereOS VM. The agent ran for 1,000 turns on its first attempt. It never left the bedroom. The interesting part was not the game. It was what happened next.
The agent’s logs streamed through Tapes into Kafka. Flink SQL jobs ran anomaly detection in real time, catching stuck loops and token spikes. An observer process extracted patterns after each run and wrote them to markdown files. The next generation of agents read those observations before starting. Over four runs, improvement rates went from 1 out of 10 generations to 4 out of 10. The telemetry pipeline turned game logs into a self-improving feedback loop.
Sweeper. I built Sweeper to show the same pattern works on real codebases. It takes a linter, groups issues by file, and fans out parallel Claude Code sub-agents, each running in its own stereOS VM. Every sub-agent session records to Tapes. I pointed it at contributor.info: 1,992 ESLint errors, 842 requiring agent fixes across 99 files. Three rounds, 100% fix rate, about 54 minutes. Then I pointed it at docs and it rewrote 15 stale feature pages with parallel agents.
Kafka + Flink. The self-healing feedback loop is where it all comes together. Agent telemetry flows through Tapes into Kafka, fans out to Flink for real-time detection, JSONL sinks for persistence, and DuckDB for ad-hoc queries. The observation layer is not just recording what happened. It is generating the signals that guide the next run.
The Response
The announcement tweet hit 150,000 views. The excitement confirmed what we had been hearing in private conversations: people building with agents are running into the exact infrastructure gaps we are solving. The response was not just engagement. It was engineers saying “I need this right now.”
What’s Next
We are building a cloud product. Tapes and stereOS are open source and self-hosted today. The cloud layer will add org-scoped session management, cost tracking, anomaly detection, and the ability to share and compare agent sessions across a team. If you are running agents in production and want to see what they are actually doing, that is what we are building toward.
Agents Are a New Workload Class
Right now, most teams are bolting agents onto existing infrastructure. An API here, a sandbox there, a proxy in the middle. It’s practical. It's reasonable. It’s also what things looked like before container runtimes existed.
New workload classes don’t get duct-taped onto old substrates forever. VMs changed what we could do with hardware. Containers changed how we shipped software. Serverless changed the unit of deployment. Each time, the durable companies were the ones that defined the new substrate layer.
Models are the hardware moment. Agent infrastructure is the substrate moment. The next category-defining companies won’t sit above the model. They’ll sit beneath it.
The thesis has not changed since April 2025. AI infrastructure still has a long way to go. The difference is we are no longer observing the gap. We are filling it.
If you are running agents in production and want to see what they are actually doing, start with Tapes. It is open source, self-hosted, and takes minutes to set up.
tapes.dev · stereos.ai · github.com/papercomputeco · Discord