# Paper Compute

> Paper Compute is the intelligence hub for AI-native teams: capture winning AI sessions, turn them into reusable skills, and keep workloads durable, observable, and self-healing.

Paper Compute builds telemetry, runtime, and operator tooling for AI-native teams. The site covers the company, the products tapes and stereOS, replayable demos, evergreen concepts, and blog posts about observability, durability, and how successful AI work becomes reusable team knowledge.

## Current context
- Paper Compute now positions itself as the intelligence hub for AI-native teams.
- The homepage emphasizes capturing winning AI sessions and turning them into reusable skills.
- Core capabilities highlighted on the site are reporting, skill generation, anomaly detection, knowledge sharing, live visibility, and runbook or documentation generation.
- tapes is the telemetry and replay layer for AI agents.
- stereOS is the hardened runtime and isolation layer for agent execution.

## Set up the paperctl CLI (for agents)
- To install and configure the paperctl CLI for a user, fetch https://papercompute.com/start.md and follow its steps in order. It covers install, login, and launching Claude Code, Codex, or Pi through paper.
- Verify setup with `paperctl status`; sessions appear at https://console.papercompute.com.

## Recommended entry points
- https://papercompute.com/start — Get set up on paper: Setup wizard for installing the paperctl CLI and launching an agent through it. A raw-markdown version lives at /start.md for agents.
- https://papercompute.com/ — Home: Current product positioning, the intelligence hub overview, and the feature set around sessions, skills, reporting, visibility, and debugging.
- https://papercompute.com/concepts — Concepts: Evergreen reference pages covering agent infrastructure, telemetry for agents, and agent observability.
- https://papercompute.com/blog — Blog: Product thinking, architecture notes, and operating guidance for AI systems in production.
- https://papercompute.com/gmail — Gmail Demo: Replayable workflow demo that shows an agent operating with a full execution history.
- https://papercompute.com/parallel — Parallel Demo: Demo of agents spawning agents, with isolation, tracking, and recoverability.
- https://papercompute.com/confluent — Confluent: Enterprise-focused page describing how Paper Compute fits event-driven and operational workflows.

## Documentation — Get started
- https://papercompute.com/docs/paper — paper: paper captures agent sessions as durable history so your team can inspect, search, and learn from the work agents do over time.
- https://papercompute.com/docs/paper/quickstart — Quickstart: Install paperctl, capture your first agent session, then prove the value — inspect it, price it, and find it by search.
- https://papercompute.com/docs/paper/how-capture-works — How capture works: The path a session takes from your agent to searchable history — the daemon, the gateway, transcript upload, and what happens when something is offline.

## Documentation — CLI
- https://papercompute.com/docs/paper/cli — CLI overview: What the paperctl CLI does, how it relates to the paperd daemon and paper console, and where to go for install, capture, and session workflows.
- https://papercompute.com/docs/paper/cli/install — Install paperctl: Install the paperctl CLI on macOS or Linux, verify the version, and understand what the installer puts where.
- https://papercompute.com/docs/paper/cli/commands — CLI command reference: Full reference for paperctl CLI commands and configuration.
- https://papercompute.com/docs/paper/cli/authenticate — Authenticate paperctl: Sign in to paper from the CLI, pick your organization, and keep the daemon's credentials healthy.
- https://papercompute.com/docs/paper/cli/claude-code — Capture with Claude Code: Run Claude Code through paperctl so every session is captured to paper console.
- https://papercompute.com/docs/paper/cli/codex — Capture with Codex: Run Codex through paperctl — with ChatGPT-plan sign-in, your own OpenAI key, or a shared team key.
- https://papercompute.com/docs/paper/cli/codex-app — Capture the ChatGPT app: Point the ChatGPT desktop app, IDE extension, and plain codex launches at paperd persistently — with Codex's own ChatGPT sign-in.
- https://papercompute.com/docs/paper/cli/pi — Capture with Pi: Run Pi through paperctl so every session is captured to paper console.
- https://papercompute.com/docs/paper/cli/conductor — Capture with Conductor: Point Conductor's workspaces at the paperd proxy so every Claude Code session Conductor runs is captured to paper console.
- https://papercompute.com/docs/paper/cli/shell-routing — Configure automatic shell routing: Make plain claude, codex, and pi route through paperctl automatically, so capture is the default instead of something to remember.
- https://papercompute.com/docs/paper/cli/sessions-list — List sessions: See your organization's recent captured sessions from the CLI, with sorting, time windows, and JSON output.
- https://papercompute.com/docs/paper/cli/sessions-inspect — Inspect a session: Read one captured session's summary from the CLI — turns, tokens, cost, duration, and status.
- https://papercompute.com/docs/paper/cli/search — Search session history: Find past agent work by meaning with paperctl search — how a problem was solved, what touched a repo, where an error came up before.
- https://papercompute.com/docs/paper/cli/sessions-export — Export session data: Pull captured sessions out as NDJSON — one session, a time window, or everything in the trailing 30 days.
- https://papercompute.com/docs/paper/cli/custom-backends — Custom backends: Codex works by default. Customize Paper backends — recreate them on a custom gateway, or set up a team-managed OpenAI key.

## Documentation — Console
- https://papercompute.com/docs/paper/console — paper console: paper console is where captured agent work becomes durable history — searchable, inspectable, and useful to teams over time.
- https://papercompute.com/docs/paper/console/team-workspace — Team workspace: Switch orgs and gateways, filter the Sessions list, and read the aggregate dashboard for your team.
- https://papercompute.com/docs/paper/console/session-data — Understand session details: What is captured in a single session detail page — turns, tool calls, telemetry, outcomes, reference thread, author — plus how to export or delete a session.
- https://papercompute.com/docs/paper/console/insights — Insights: How to read the Insights page in paper console — spend, usage, and session health across your team, and how to turn the aggregates into sessions worth opening.
- https://papercompute.com/docs/paper/console/manage-team-workspace — Manage your team workspace: Organizations, members, roles, and invitations in paper console — who can see what, and how to bring the team in.

## Documentation — Skills
- https://papercompute.com/docs/paper/console/skills — Skills: Turn a captured session into a reusable skill — generate it from real work, version it, and share it with your team.
- https://papercompute.com/docs/paper/guides/publish-your-first-skill — Publish your first skill: A complete walkthrough from a captured agent session to a published, downloadable skill in paper console.
- https://papercompute.com/docs/paper/guides/skills-from-the-cli — Turn sessions into skills from the CLI: The full skills loop without leaving the terminal — find the session where you already solved it with paperctl search, generate a skill from it, and sync the SKILL.md into your agent's skills directory.
- https://papercompute.com/docs/paper/skills/install — Install a Skill: Put a published paper Skill where your agent can use it — one paperctl command installs it and the same command updates it.
- https://papercompute.com/docs/paper/guides/roll-out-a-team-skill-library — Roll out a team skill library: A lead's playbook for setting up a shared skill library — capture every agent your team runs, seed skills from the CLI or paper console, and make reuse a habit.

## Documentation — Troubleshooting
- https://papercompute.com/docs/paper/cli/troubleshooting — Troubleshooting: Resolve daemon, authentication, and capture issues with the paperctl CLI.

## Documentation — Reference
- https://papercompute.com/docs/paper/reference/glossary — Glossary: Canonical definitions for paper's product nouns — session, turn, trace, span, gateway, Skill, and the rest — used consistently across the docs.

## Foundational product posts
- https://papercompute.com/blog/introducing-paper-compute/ — Introducing Paper Compute Co: Infrastructure for Running AI Agents in Production (2026-03-31): We built Paper Compute to close the Agent Gap — the inability to prove what an agent did, audit its actions, or replay its decisions. Here's what we built and why.
- https://papercompute.com/blog/introducing-stereos/ — Introducing stereOS: An operating system for your agent (2026-02-27): stereOS is a NixOS based operating system designed for AI agents to be secure, self-managed, and efficient
- https://papercompute.com/blog/introducing-tapes/ — Introducing tapes: Transparent Telemetry for AI Agents (2026-02-10): We built tapes to solve the observability gap in AI agent infrastructure. Every session recorded, every decision searchable, every conversation replayable.

## Concepts
- https://papercompute.com/concepts/agent-turns — Agent Turns: What Actually Happens During an Agent Turn?: A visual, interactive introduction to agent turns, model invocations, tool calls, tool results, repeated calls, and the structured records beneath a chat reply.
- https://papercompute.com/concepts/agent-reply-cost — Why Does a Three-Sentence Agent Reply Cost So Much?: An interactive explanation of how context, model invocations, tokens, compaction, and prompt caching shape the cost of an agent reply.
- https://papercompute.com/concepts/agent-session-trees — Your Agent Is a Tree, Not a Chat: A visual introduction to subagents, parent and child sessions, session topology, and the difference between parent totals and whole-tree totals.
- https://papercompute.com/concepts/agent-telemetry-limits — What Agent Telemetry Can—and Can't—Tell You: An interactive guide to field dependencies in agent telemetry: remove fields from one session and watch answerable questions degrade into unknowns.
- https://papercompute.com/concepts/enterprise-inference-gateway — Enterprise Inference Gateway: What It Is, Why You Need One, How to Build (or Buy) One — 2026 Reference: An enterprise inference gateway centralizes AI inference traffic for capture, policy, egress, telemetry, replay, and audit. Build-vs-buy reference for 2026.
- https://papercompute.com/concepts/ai-platform-engineering — AI Platform Engineering: What It Is, Who Does It, and Why It's Becoming a Platform Function: AI platform engineering is the practice of running AI tools as a governed enterprise platform — shared inference, capture, policy, cost, and governance. The mandate, the stack, and the maturity model for 2026.
- https://papercompute.com/concepts/llm-proxy — LLM Proxy: Network-Level AI Request Capture and Policy Enforcement: An LLM proxy intercepts AI-API calls between tools and model providers for capture, policy enforcement, telemetry, and audit. The primitive behind enterprise inference gateways and AI platform engineering.
- https://papercompute.com/concepts/ai-session-capture — AI Session Capture: How Proxy-Layer Capture Records Prompts, Responses, and Tool-Use Events: AI session capture records model requests, responses, tool-call payloads, and metadata as they pass through the provider/API path, creating the durable record that replay, telemetry, governance, and skill extraction depend on.
- https://papercompute.com/concepts/agent-session-replay — Agent Session Replay: Reconstructing AI Agent Runs from Captured Session Records: Agent session replay reconstructs a captured AI agent run — prompts, responses, tool-use events, results, and metadata — in original sequence, so engineers can debug, audit, and compare non-deterministic behavior.
- https://papercompute.com/concepts/telemetry-for-agents — Telemetry for Agents: Continuous capture of every input, output, and interaction an AI agent produces—a structured record of behavior you can inspect, analyze, and trust.
- https://papercompute.com/concepts/agent-observability — Agent Observability: The practice and system capability of understanding what AI agents are doing, why they made certain decisions, and whether they are behaving as intended. It is built on telemetry and extends into analysis, detection, and response.
- https://papercompute.com/concepts/agent-infrastructure — Agent Infrastructure: The primitives that sit between models and production: orchestration, isolation, storage, and the control plane for agent workloads.
- https://papercompute.com/concepts/ai-agent-skills — AI Agent Skills: Reusable Workflows for Agentic Systems: AI agent skills are reusable, versioned instructions or workflow artifacts that help agents apply known procedures, tool-use patterns, and troubleshooting steps across future runs.
- https://papercompute.com/concepts/skill-extraction — Skill Extraction: Skill extraction turns a recorded agent session into a reusable skill: the procedure, tool sequence, decisions, and known fixes that made the session work, lifted into a reviewable, versioned artifact.
- https://papercompute.com/concepts/skill-library — Skill Library: A skill library is the versioned, reviewable collection of skills a team maintains — each scoped, typed, and traceable to the sessions it came from — so individual extractions become durable team capability.
- https://papercompute.com/concepts/skill-invocation — Skill Invocation: Skill invocation is the runtime step where an agent matches the task in front of it against a skill's trigger conditions and loads the matching skill before acting — the step that decides whether a library's knowledge actually reaches a run.
- https://papercompute.com/concepts/build-team-skill-library-from-ai-usage — How to Build a Team Skill Library From Real AI Usage: Most teams write AI skills from scratch — from memory, by hand, by someone who hopes they got it right. Building the library from captured session data produces a different kind of library: one that compounds instead of decaying.
- https://papercompute.com/concepts/skill-drift — Skill Versioning and Drift: How teams keep reusable agent skills reliable as tools, models, and tasks change: drift signals beyond hard failure, the versioning-evaluation-promotion-rollback lifecycle, common maintenance failure modes, and when the discipline pays off.
- https://papercompute.com/concepts/claude-code-sessions-to-reusable-skills — Turning Claude Code Sessions Into Reusable Skills: A recorded Claude Code session holds the tool sequence, decisions, and fixes that solved a real problem. Learn how to keep that record with paperctl and shape it into a versioned skill your agent applies the next time the task recurs.
- https://papercompute.com/concepts/learning-from-agent-sessions — Learning from Past AI Agent Sessions: How to get better results from AI agents by systematically reading past sessions for reusable patterns: the signals to look for, how to turn them into skills, and how the feedback loop compounds.
- https://papercompute.com/concepts/agent-skills-vs-memory — Agent Skills vs Memory, RAG, and Fine-Tuning: When to reach for agent skills versus memory, RAG, or fine-tuning: how each mechanism works, a four-way comparison, a worked rollback example, the failure modes of picking the wrong one, and the decision signals for each.
- https://papercompute.com/concepts/continuous-agent-improvement — Continuous Agent Improvement: The practice of using captured agent sessions, analysis, reusable skills, and shared knowledge to improve future agent runs without retraining the model.
- https://papercompute.com/concepts/team-shared-agent-knowledge — Team-Shared Agent Knowledge: The practice of making every agent session's insights available to every engineer on the team — via searchable history, annotated traces, and versioned skills — so individual problem-solving compounds into team capability.
- https://papercompute.com/concepts/ai-agent-institutional-knowledge — AI Agent Institutional Knowledge: The organizational memory that accumulates from AI agent usage: team decisions, solved problems, and recurring patterns that outlast any individual session.
- https://papercompute.com/concepts/ai-coding-session-analysis — AI Coding Session Analysis: Capture, Search, and Learn from Agent Runs: The main ways to capture and analyze AI coding sessions (raw session history, application-level instrumentation, telemetry-based tracing, provider-boundary capture, and purpose-built session analysis), what each can observe, and what analysis produces.

## Latest blog posts
- https://papercompute.com/blog/dont-just-measure-code-measure-engineering-decisions/ — Don't Just Measure Code. Measure Engineering Decisions. (2026-09-02): The cost of an engineering decision is not the cost of making it. It's the work the decision causes afterward. We traced one architecture decision through 474 agent session records: $4,704.74 downstream of a $57 design doc, and four metrics (reach, duration, rework, amplification) any team with session records can track.
- https://papercompute.com/blog/cassette-anatomy/ — The Anatomy of a Cassette (2026-08-26): tapes captures your AI agent data, and a cassette is a small service that adds
your own capabilities on top of it, served through the tapes API. This post walks
through building one end to end: the API, its OpenAPI spec, and an MCP tool.

- https://papercompute.com/blog/how-to-share-agent-knowledge-across-a-team/ — Your Team's Knowledge Is Hiding in Sessions Nobody Reopens (2026-08-24): We analyzed two months of our team's sessions to find out what should become reusable knowledge. What we found is that repeatable work matters more than frequent work.
- https://papercompute.com/blog/paper-clearings/ — paper clearings: How We Develop a Hosted Platform with Disposable Local Clouds (2026-08-20): Parallel source trees are cheap; parallel runtimes are not. How a disposable, fully isolated platform environment per working tree lets multiple problems — worked by humans or agents — run side by side on one laptop.
- https://papercompute.com/blog/tapes-open-core/ — Tapes: Free and Open AI Data (2026-08-17): How we're building the free and open source building-blocks for the future of AI data
- https://papercompute.com/blog/dreams-on-paper/ — Dreams, Reflections, and Inceptions (2026-08-12): Dreams sound mystical. In practice, they are a way to label agent traces, reflect across sessions, and turn repeated behavior into something the next run can use.
- https://papercompute.com/blog/how-to-reduce-ai-agent-costs/ — How to Reduce AI Agent Costs (2026-08-11): I audited our agent sessions expecting to find wasteful repeat calls. Repeats were only 4%. The real money was in agents re-reading what they already knew, plus a permission-check tax we could finally put a price on.
- https://papercompute.com/blog/high-fi-traces/ — What is in a High-Fidelity trace? (2026-08-06): What we see our AI agents doing may not be exactly what's going on under the hood.


## Changelog
- https://papercompute.com/changelog/ — Release notes for paper, the console, tapes, and stereOS. Full feed at https://papercompute.com/changelog.xml.
- https://papercompute.com/changelog/2026-08-10-chatgpt-app-capture/ — Capture the ChatGPT app (2026-08-10): One command points the ChatGPT desktop app, IDE extension, and plain codex launches at paperd persistently — Codex keeps its own ChatGPT sign-in, and every session lands in paper console.
- https://papercompute.com/changelog/2026-08-10-codex-subagents-inline/ — Codex subagents render inside their parent session (2026-08-10): Codex spawn_agent threads now appear inline in the parent session's trace — nested under the tool call that spawned them, at any depth — and the session's usage and cost totals include them.
- https://papercompute.com/changelog/2026-08-05-self-serve-billing/ — Upgrade your plan from settings (2026-08-05): Settings → Billing used to only tell you which plan you were on. Now it sells them: pick Start or Scale, pay through Stripe, and you're on it.
- https://papercompute.com/changelog/2026-07-23-paperctl-v0-21/ — paper is now paperctl — and installs no longer need sudo (2026-07-23): v0.21.0 renames the CLI binary from paper to paperctl, moves installs to a user-owned directory with no sudo anywhere, and adds paperctl upgrade so you never run the curl ritual again.
- https://papercompute.com/changelog/2026-07-23-session-models/ — See models in session table (2026-07-23): The sessions table now shows each session's model at a glance: the cost-dominant model with its logo, a +n badge when more than one was involved, and a hover breakdown of what each model cost.
- https://papercompute.com/changelog/2026-07-17-session-outcomes/ — Every session shows its outcomes (2026-07-17): Session detail pages now show what a session actually produced. Pull requests, repos, GitHub issues, Linear issues, or a plain "no outcome" if it made nothing.
- https://papercompute.com/changelog/2026-07-14-paper-sessions-cli/ — paperctl sessions in the CLI (2026-07-14): paperctl sessions brings list, get, and export to the CLI. Browse your captured sessions and stream them out as NDJSON without opening the console.
- https://papercompute.com/changelog/2026-07-11-export-sessions/ — Export your session data (2026-07-11): Your sessions are yours to take with you. Export any single session, or the last 30 days as a bundle, as full-fidelity JSONL.
- https://papercompute.com/changelog/2026-07-10-delete-sessions/ — Delete sessions from the console (2026-07-10): Sessions used to be read-only. Now every session detail page has a delete control that removes the session and everything it spawned.
- https://papercompute.com/changelog/2026-06-30-insights-dashboard/ — Insights dashboard for spend and session health (2026-06-30): A new Insights page in console charts spend over time, breaks it down by model and session, compares against the previous period, and surfaces prioritized observations about cost outliers and failed runs.