# 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 — Gateway
- https://papercompute.com/docs/paper/gateway — Gateway overview: What a paper gateway is, why your organization has one, and how it connects your agents, paperd, backends, providers, and paper console.
- https://papercompute.com/docs/paper/gateway/choose — Choose your gateway setup: Decide which gateway configuration fits your team — the default, extra gateways, transparent or managed credentials, paperd or direct access.
- https://papercompute.com/docs/paper/gateway/manage — Manage gateways: Create, inspect, switch, and delete your organization's gateways from paper console or the paperctl CLI, and read provisioning status.
- https://papercompute.com/docs/paper/gateway/backends — Backends and providers: Configure provider routes on a paper gateway — schemas, model allowlists, transparent or managed credentials, and the Codex key options.
- https://papercompute.com/docs/paper/gateway/api-keys — Gateway API keys and direct access: Create per-user gateway API keys in paper console and call your gateway directly from CI, scripts, and SDKs — with capture intact.

## 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: Capture the ChatGPT desktop app, IDE extension, and plain codex launches through paperd. Choose setup for ChatGPT sign-in or an OpenAI API key.
- 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/zed — Capture with Zed: Point Zed's Claude agent at the paperd proxy so every session you run from Zed's agent panel 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.

## 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/digests — Read the dashboard digest: A written summary of what your team actually accomplished in a period — accomplishments, next steps, and topics, right on the dashboard.
- https://papercompute.com/docs/paper/cli/labels — Organize sessions with labels: Tag captured sessions and skills with your own labels, then filter, sort, and manage your history by them — a shared vocabulary for the work your team cares about.
- 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/skills/evals — Evaluate a skill: Run a skill evaluation in paper console — check a skill against weighted criteria and real session evidence, read the verdict, and accept an improvement when it fails.
- https://papercompute.com/docs/paper/guides/write-a-good-skill-eval — Write a good skill eval: How to write eval criteria a judge can actually check, and how to choose weights so a pass means the skill works and a failure tells you what to fix.
- 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/skill-writing-reader — Who Reads Your Agent Skill? The Strangest Audience in Writing: Learn to write agent skills by meeting the reader first: capable, literal, and starting fresh. Practice the no-op test and see what a skill is really for. Step 1 of 5 in the skill writing lab.
- https://papercompute.com/concepts/skill-writing-capture — Capture, Don't Compose: Where Good Agent Skills Come From: Good agent skills start from instructions you already give your agent, not from templates. How to save one as a small first draft, name it, choose who invokes it, and clean it up before you share it. Step 2 of 5.
- https://papercompute.com/concepts/skill-writing-patch — Patch What Broke: How Agent Skills Get Better Without Bloating: How to improve a skill without making it longer: watch what actually happens, make the smallest fix, then rerun what failed. Includes the three moves that fix a misread instruction. Step 3 of 5.
- https://papercompute.com/concepts/skill-writing-style — How to Write a Skill so Your Agent Can Follow It: Learn how to write in a style your agent can follow. Step 4 of 5.
- https://papercompute.com/concepts/write-your-first-agent-skill — Write Your First Agent Skill, Test It, and Publish It: The final step of the skill writing lab: build the SKILL.md file, test it against real tasks, then publish it in paper console so your team can install it.
- https://papercompute.com/concepts/ai-gateway — AI Gateway: What It Is, How It Works, and Why Platform Teams Need One: An AI gateway sits between a company's AI tools and its model providers, giving the platform team one place to choose models, enforce rules, keep records, and track cost. This pillar teaches the request path, what a gateway can and cannot see, how routing works, the reference architecture, and a working taxonomy for the terms around it.
- 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: What It Is and How It Works: An LLM proxy sits between an AI tool and a model provider: the tool sends requests to the proxy, and the proxy records them, applies rules, and forwards them. This page explains how interception works, what a proxy can and cannot see, how it differs from a full AI gateway, and how it compares with SDK and OpenTelemetry instrumentation.
- https://papercompute.com/concepts/semantic-gateway-vs-inference-gateway — Semantic Gateway vs Inference Gateway: A semantic gateway decides how to handle a request based on its meaning; an inference gateway is the control plane that governs, captures, and meters model traffic. This page compares the two, shows where each sits, and explains why most production stacks run both.
- https://papercompute.com/concepts/semantic-gateway — What Is a Semantic Gateway?: A semantic gateway is an AI gateway that uses what a request means as a routing signal. This page defines the pattern, shows how content-aware routing works, and covers the parts most writing skips: classifier latency, confidence handling, how policy constrains routing, evaluation against business outcomes, and the safety and privacy implications of classifying prompts.
- https://papercompute.com/concepts/semantic-routing-vs-model-routing — Semantic and Model Routing: Decision Signals, Destinations, and Routing Quality: Routing in an AI gateway is best described on two axes: the signal that drives the decision (static config, prompt semantics, learned quality scores, availability, latency, budget, policy) and the destination it resolves to (model, provider, endpoint, tool, cache, workflow, or rejection). This page maps the axes, explains why semantic and model routing overlap more than the labels suggest, and covers how to measure routing quality.
- https://papercompute.com/concepts/jev — What Is Jev? TypeSafe AI's Decision Model and Where It Fits in an AI Gateway: Jev returns typed decisions with calibrated probabilities instead of generated text. This page covers how Jev works (the Choice, Score, and Noul primitives), how it differs from a generative LLM, what it is used for, how it compares with rules, classifiers, and LLM routers, and where a decision model sits in an AI gateway request path.
- https://papercompute.com/concepts/probabilistic-decision-models — Probabilistic Decision Models: AI That Returns Typed Decisions with Confidence: A probabilistic decision model evaluates application state against answers declared in advance and returns one of them with a probability. This page covers how decision models work, how they differ from rules, classifiers, and generative LLMs, why calibration is the load-bearing property, how confidence thresholds turn decisions into automation policy, and where a decision model sits in an AI gateway.
- https://papercompute.com/concepts/ai-gateway-vs-llm-proxy — AI Gateway vs LLM Proxy: An LLM proxy is the network primitive that intercepts and forwards model requests; an AI gateway is the platform built on that primitive. This page compares the two, shows where the primitive ends and the platform begins, and explains why every gateway contains a proxy but not every proxy is a gateway.
- https://papercompute.com/concepts/enterprise-inference-gateway — Enterprise AI Gateway: What changes when an AI gateway becomes shared company infrastructure: the capability model, a build-vs-buy decision matrix across ownership, compliance, residency, and exit cost, and a practical three-phase rollout.
- 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/model-routing — Model Routing: Choosing the Right Model for Each Request: Model routing is the practice of choosing which model serves each request to hit a cost, quality, or latency target. This hub covers how model routing works, static versus dynamic routing, the published evidence, its failure modes, and the routing strategies that specialize it.
- 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/cost-aware-model-routing — Cost-Aware Model Routing: Cost-aware model routing sends each request to the cheapest model that still meets a quality bar, tuned by a cost knob. This page explains how the cost-quality tradeoff is controlled, where the savings come from, the guardrails that keep quality from slipping, and how to measure it.
- https://papercompute.com/concepts/workload-aware-model-routing — Workload-Aware Model Routing: Workload-aware model routing chooses a model from the shape of the work (agentic multi-turn sessions, tool-heavy loops, latency budgets, context length) rather than the difficulty of a single prompt. This page defines it, contrasts it with per-request cost routing, and shows where the workload signal comes from.
- https://papercompute.com/concepts/model-routing-evals — Model Routing Evals: Proving a Router Before You Trust It: Model routing evals measure whether a router holds quality while it saves cost: quality retained versus the strong model, spend reduced, strong-model call fraction, and misroute rate. This page covers the metrics, the baselines, offline replay versus online tests, and the drift that evals catch.
- 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/using-agent-session-data-for-model-routing — Using Agent Session Data for Model Routing: A router trained on public benchmarks routes a generic workload; a router informed by a team's own captured agent sessions routes the workload it actually has. This page explains what session data adds to routing, how it feeds offline replay and drift detection, and its limits.
- https://papercompute.com/concepts/frontier-vs-open-weight-model-routing — Frontier vs Open-Weight Model Routing: Routing between hosted frontier models and self-hostable open-weight models trades capability against cost, privacy, latency, and control. This page explains the drivers, how sensitive traffic routes to internal models, and how to decide the cut.
- https://papercompute.com/concepts/ai-gateway-vs-api-gateway — AI Gateway vs API Gateway: An API gateway manages structured REST and GraphQL traffic; an AI gateway manages prompt and response traffic where the payload is natural language and cost is measured in tokens. This page compares the two, shows where they overlap, and explains why AI gateways are often built on API-gateway data planes.
- https://papercompute.com/concepts/ai-gateway-vs-mcp-gateway — AI Gateway vs MCP Gateway: An AI gateway governs model traffic (prompts and responses); an MCP gateway governs tool traffic between agents and Model Context Protocol servers. This page compares the two, shows how an agent uses both, and explains why they are complementary control points rather than competitors.
- https://papercompute.com/concepts/ai-gateway-observability — AI Gateway Observability: AI gateway observability is the visibility a gateway gives platform teams into model traffic: token and cost metrics, latency, per-model and per-team breakdowns, the captured prompt and response, and the routing decision. This page covers what it measures, how it differs from generic APM, and its failure modes.
- 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/ai-gateway-data-residency — AI Gateway Data Residency: AI gateway data residency is the control a gateway gives over where prompt, response, and captured AI data is processed and stored. This page covers the residency levers a gateway exposes (provider region routing, which providers are reachable, where the capture archive lives, routing to in-region or self-hosted models) and the failure modes.
- https://papercompute.com/concepts/ai-gateway-build-vs-buy — AI Gateway Build vs Buy: Should a platform team build an AI gateway, buy a turnkey one, or adopt an open-source primitive and build the platform layer on top? This page lays out the three paths, the factors that decide between them, and the trap of rebuilding a v1 that skipped the hard parts.
- https://papercompute.com/concepts/ai-gateway-for-coding-agents — AI Gateway for Coding Agents: Coding agents like Claude Code, Codex, Pi, and Zed are high-volume, tool-heavy, multi-turn workloads. Routing them through an AI gateway adds capture, cost control, model routing, and governance without changing the agent. This page covers how, what it enables, and the failure modes.
- https://papercompute.com/concepts/model-routing-drift — Model Routing Drift: Model routing drift is the silent degradation of a routing policy as models, prices, providers, and workloads change underneath it. This page defines the drift, its causes, why it is invisible without evals, and how re-evaluation on fresh traffic catches it.
- https://papercompute.com/concepts/ai-gateway-maturity-model — AI Gateway Maturity Model: The AI gateway maturity model describes five levels a team moves through as it governs AI traffic: ungoverned, captured, governed, routed, and adaptive. This page defines each level, the trigger that advances it, and how to use the model to assess where you are and what to build next.
- 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/daytona-fanout-keep-the-tapes/ — Run the Sweep on Daytona. Keep the tapes. (2026-10-13): Daytona lets me spin agent sandboxes up and down quickly. Keeping the session data with tapes means the next sweep can learn from work I've already paid for.
- https://papercompute.com/blog/use-the-right-ai/ — Using the right AI should be the easy part (2026-10-07): Picture an office building with no front desk: everyone has a key to every door, and nobody knows who's inside or what it costs. That's most companies' AI setup. An AI gateway is the front desk. The next two layers make the desk smarter: it starts asking what kind of work you're here for, and then it learns whether the work succeeded. The best way to use AI should also be the easiest.
- https://papercompute.com/blog/train-a-model/ — Train a Model on Your Own Agent Sessions (2026-10-01): How I turn labeled agent sessions into training examples and evaluation cases, keep the two separate, and use Databricks and MLflow to organize the data and compare model runs.
- https://papercompute.com/blog/ai-made-silos-easier/ — AI Made Silos Easier (2026-09-28): Agentic development removed the friction that used to leak knowledge across a team. The work got faster, and keeping everyone caught up got harder.
- https://papercompute.com/blog/from-traces-to-training-data-jev/ — Tracing. Where Jev Fits (2026-09-22): Jev judged 1,781 engineer turns from 138 of my team's agent sessions with a 188 ms median response and recovered 100% of the human-accepted question-label examples. Here's how it compared with GPT-4o mini, Claude Haiku 4.5, and a local Qwen model.
- https://papercompute.com/blog/your-agent-work-is-already-a-dataset/ — Your Agent Work Is Already a Dataset (2026-09-21): Agent telemetry can price every session to the penny and still can't say what the work was for. Labels attach intent while it's still known, and a few months of them becomes a dataset of engineering work indexed by why.
- 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.


## 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-09-17-claude-artifact-outcomes/ — Claude artifacts count as outcomes (2026-09-17): A session that published a Claude artifact now shows it in Outcomes, with its own label and icon, linked to the published page.
- https://papercompute.com/changelog/2026-09-16-skill-evals/ — Skill evals (2026-09-16): Every skill has a Skill evals panel. Run an evaluation on the revision you're looking at and get a pass or needs-revision decision, a score, and a verdict per criterion.
- https://papercompute.com/changelog/2026-09-15-labels/ — Label sessions and filter by them (2026-09-15): Sessions take labels. A Labels column on the sessions list shows them, clicking one filters the list, and a Labels control in the toolbar does the same without a chip on screen.
- https://papercompute.com/changelog/2026-09-15-weekly-digest/ — A digest on the dashboard (2026-09-15): The dashboard leads with a digest of the selected window. A summary, then highlights you can rate.
- 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.