About Paper Compute.
As agents move from demos into real engineering workflows, teams need more than prompts and model access. They need durable records of what agents did, secure environments where agents can run, and systems that help successful work compound instead of disappear.
Paper Compute exists to make agent work durable, understandable, and reusable.
We build tools that help teams capture agent activity, route model traffic, understand what happened, and turn repeated workflows into shared knowledge.
Most agent work is still treated as disposable. Paper Compute changes that.
A developer can spend an hour guiding an agent through a hard task. The agent tries commands, edits files, hits dead ends, calls tools, retries, recovers, and eventually succeeds.
The final diff might survive.
The process usually does not.
That is a problem.
Every meaningful agent session contains more than an output. It contains prompts, responses, retries, tool calls, execution paths, failures, recoveries, and decisions. That activity is the raw material teams need to debug agents, improve workflows, enforce policy, share knowledge, and understand how AI is actually being used.
If the work mattered, the record should matter too.
Developer experience meets production infrastructure.
Paper Compute was founded from two complementary perspectives: developer experience and production infrastructure.
One perspective comes from years spent close to how developers actually work: inside open source communities, developer workflows, documentation systems, and the messy human side of adopting new tools.
The other comes from building systems that have to hold up in production, where every action needs to be understood, audited, secured, and trusted.
Those perspectives kept running into the same question:
What exactly happened, and can you prove it?
That question matters even more now.
As agents begin touching codebases, tools, customer data, production systems, and internal workflows, teams need infrastructure that can preserve agent activity, explain agent behavior, and create a durable record of work.
Paper Compute is built for that world.
Four products. One system for agent work.
paper is the command line for Paper Compute.
It gives developers a fast path from a fresh machine to a working AI proxy that captures Claude Code sessions without manually configuring gateways, backend routing, or long-lived API keys in the shell.
With paper, developers can start capturing agent activity from the tools they already use. Today, paper supports Claude Code. More clients and providers are coming.
The goal is simple: make agent telemetry easy enough to use every day.
paper console is the managed layer for teams.
It gives teams a place to collect, organize, search, and learn from agent sessions. Instead of leaving agent work scattered across individual machines, chat histories, or short-lived logs, paper console helps teams build shared memory from the work their agents are already doing.
paper console is where captured sessions become team-level knowledge: searchable histories, reusable workflows, policy-aware records, and higher-quality data for improving agent performance over time.
tapes is the open source trace layer behind Paper Compute.
It records agent and LLM activity so teams can preserve the full context of a session: requests, responses, tool calls, retries, execution paths, and the steps that led to a result.
tapes is the telemetry foundation. paper makes it easy to use. Paper Cloud makes it useful for teams.
stereOS is a secure runtime environment for AI agents.
As agents gain access to files, tools, networks, and compute, teams need stronger boundaries around where agents run and what they can do.
stereOS is designed for that world: sandboxed execution environments for agentic workloads.
The next generation of AI infrastructure will not be defined by model access alone.
It will be defined by the systems around the model:
- —how agent sessions are captured
- —how model traffic is routed
- —how teams debug and replay agent behavior
- —how successful workflows become reusable skills
- —how companies preserve knowledge from agent work
- —how agents run safely in controlled environments
- —how teams prove what happened when an agent takes action
Agents need more than prompts.
They need infrastructure for memory, telemetry, routing, security, and continuous improvement.
Teams moving beyond one-off AI experiments.
Paper Compute is for teams moving beyond one-off AI experiments and into real agent workflows. That includes:
- —developers using Claude Code and other coding agents
- —platform teams building internal AI infrastructure
- —engineering teams trying to understand agent usage across projects
- —security teams evaluating agent risk
- —companies that want agent work to compound instead of reset every day
- —teams preparing to run agents in production environments
Founders.
Brian previously founded Open Sauced, where he worked on increasing knowledge and adoption within open source communities. His current focus is AI infrastructure and agent systems — building observational memory pipelines using Kafka, Flink, and DuckDB to help agents get better every run.
Read posts by bdougie →
Denver-based software engineer and open source contributor focused on AI agent infrastructure and security. Creator of stereOS, a Linux-based operating system for running AI agents with security hardening, and tapes, an open-source telemetry tool for transparent AI agent monitoring.
Read posts by john →Start with paper
Turn every session into knowledge at team scale.