Which Paperclip adapter for which agents?

The adapter is the setting that determines where and how an agent runs. Paperclip configures this per agent, which means different agents in the same company can run on different runtimes, matching the right tool to the right job.

Paperclip ships several adapter types, from Claude and Codex to Hermes, Gemini, and others. The four you will reach for most often are claude_local, codex_local, hermes_local, and opencode_local. Paperclip's documentation labels Claude Code "(Recommended)" in the adapter picker and calls it the most commonly used adapter for Paperclip agents, so that is where most operators start. But the documentation names no default adapter — it states other create-time defaults and not this one — and the adapter is a per-agent choice, so when a specific agent has a specific constraint, whether a code-first workload, a need to keep data (and optionally inference) on your own infrastructure, or cost optimisation across many agents, the choice starts to matter. This page maps it.

The four adapters

claude_local: hosted Claude, the recommended starting point

claude_local runs the agent on a hosted Claude model. The model is set in the agent's adapter config; Paperclip's adapter reference names Opus, Sonnet and Fable as common choices, and the field accepts any model id you type rather than restricting you to the listed ones. Anthropic hosts and serves that model by default. AWS Bedrock is the documented path where it does not: the adapter supports Bedrock settings as one of three auth modes, and where it detects Bedrock — for example from CLAUDE_CODE_USE_BEDROCK=1 — it offers the region-qualified Bedrock model ids instead.

Setup is not configuration alone. Claude Code is a separate Anthropic product that must be installed on the Paperclip host and available on PATH, with auth configured — an Anthropic API key, Bedrock settings, or Claude subscription login — before an agent on this adapter will run.

Paperclip labels this adapter "(Recommended)" in the picker and describes it as the most capable and most commonly used adapter for Paperclip agents. That is a recommendation, and the documentation names no default — you pick an adapter for each agent at create time, and it gives claude_local and codex_local the same availability tier. Claude's documented strengths as a worker are reasoning capability and tolerance for ambiguous or multi-step problems. Good choice for most agent types.

codex_local: OpenAI Codex as worker

codex_local runs the agent on OpenAI Codex as the worker model. It is the code-first alternative to claude_local: specialised for code generation, modification, and testing, with a different pricing structure to Anthropic models. The per-agent choice means you can run an executive agent on claude_local and deploy codex_local across code-focused workers.

hermes_local: self-hosted, persistent memory, your infrastructure

hermes_local is the own-infrastructure adapter. claude_local and codex_local both resume their previous session on the next heartbeat, so the conversation carries across runs; what does not carry is a store the agent can write facts into and read back. hermes_local maintains its own memory store that survives across runs. The agent can store and retrieve facts, summaries, prior decisions, and accumulated findings between executions: structured, searchable knowledge the agent writes for itself.

hermes_local also ships with a large built-in toolset, expanding the problem classes it can address. At Hermes release v0.21.3 (tag v2026.9.14), the project's own built-in tools reference put the registry at roughly 86 tools and said on the same line that availability varies by platform, credentials and enabled toolsets — a dozen of them register only in a desktop session, a dozen more only when the kanban dispatcher spawns the agent. Read that as a ceiling you configure down to, not a number every agent sees. The trade-off: memory operations add to runtime cost, and you run the Hermes runtime on your own infrastructure.

Read, not run. The tool-registry figures in this section were read on 2026-09-17 from website/docs/reference/tools-reference.md in the Hermes repository at release tag v2026.9.14 (published 2026-09-14). That page states the count as approximate and platform-dependent, so it is a figure for that tag rather than a fixed capability: Hermes ships every two to three weeks, and the number moves with it. Check the count against the release you actually run.

Hermes comes in two adapter variants. hermes_local runs Hermes as a local subprocess on the same machine as Paperclip; hermes_gateway connects Paperclip to a remote Hermes instance already running on another host or VM, over its HTTP/REST API. Reach for hermes_gateway when the Hermes runtime lives elsewhere, and hermes_local when the two share a host.

hermes_local is model-agnostic: it runs Claude, open-weight models, or a fully local model, so you get persistent memory and that toolset without giving up model choice. Keeping inference fully on your own hardware is an option (point it at a local model), not an automatic property.

If you have a data-residency or air-gapped requirement, or a preference for owning your runtime and memory, hermes_local is the path. Whether to bring Hermes in at all, versus running another adapter, is its own question.

opencode_local: OpenCode CLI, multi-provider

opencode_local is the OpenCode CLI adapter. It supports multiple model providers and lets you wire Manifest in front as an optional request-time router: point all agents at manifest/auto and Manifest classifies each request, picks the cheapest capable model from your provider pool, and falls back across providers when one hits a cap.

This is useful when you are managing multiple agents across model tiers and want centralised provider routing. Avoid it when a specific agent needs a specific model's strengths, or when cost predictability matters more than cost optimisation. For full setup, see the manifest-auto-routing guide.

Comparison table

	claude_local	codex_local	hermes_local	opencode_local
Where inference runs	Anthropic hosted by default; routable to AWS Bedrock, which the adapter supports as one of three documented auth modes	OpenAI hosted by default; routable to your own gateway or provider by setting PAPERCLIP_CODEX_PROVIDERS on the Paperclip host	Your own runtime; model local or provider-routed	Configurable provider (a pool when Manifest-routed)
Persistent memory	No; the session resumes, but there is no memory store	No; the session resumes, but there is no memory store	Yes, survives across runs	No; the session resumes, but there is no memory store
Setup effort	Install Claude Code on the Paperclip host and configure auth (API key, Bedrock settings, or Claude login), then configure the agent	Install the Codex CLI on the Paperclip host and bind an OpenAI API key, then configure the agent	Higher, operate Hermes runtime	Medium, OpenCode + optional Manifest
Cost model	Anthropic per-token	OpenAI per-token	Model inference (local or per-token) + memory ops + operator infra	Optimised across provider pool
Best fit	Most agent types; the adapter Paperclip recommends	Code generation and modification	Data control, memory-intensive agents	Multi-agent cost optimisation

Recommendation by use case

• General purpose, and the adapter Paperclip recommends: claude_local. Install Claude Code on the Paperclip host, configure auth — an Anthropic API key, Bedrock settings, or Claude subscription login — then create the agent and set its model in the adapter config. This is where most operators start.
• Code generation and modification as the primary workload: codex_local. Purpose-built for code tasks with OpenAI Codex as the worker.
• Keep your data and memory on your own infrastructure (and inference too, with a local model): hermes_local. The self-hosted path with persistent memory across runs. Worth the additional setup when data residency, air-gapping, or memory continuity is the constraint.
• Managing cost across many agents and model tiers: opencode_local with Manifest. Let the router optimise; avoid it for agents that depend on a specific model's strengths.

FAQ

Can I mix adapters across agents in the same company? Yes. The adapter is configured per agent, so one company can run some agents on claude_local, others on hermes_local, and others on codex_local. The Paperclip community guide for mixed-adapter teams confirms this is the intended pattern: assign the adapter that fits the work, not the adapter you are most comfortable with.

Which adapter does Paperclip recommend when I create a new agent? claude_local — as a recommendation, not a default. Paperclip's documentation names no default adapter: it states other create-time defaults and not this one, and gives claude_local and codex_local the same "Selectable (recommended)" availability tier. What it does say about claude_local is that it is the most capable and most commonly used adapter for Paperclip agents, and its picker labels it "(Recommended)". That is why most operators choose it. The adapter is a per-agent choice, so make it deliberately for each agent you hire.

Does hermes_local require self-hosting? Yes, for the runtime. hermes_local runs its runtime and memory store on operator-owned infrastructure, and that store persists across runs. The model itself can still be a hosted provider (Claude and others) or a fully local one, so self-hosting the runtime does not force self-hosting inference. claude_local and codex_local run the vendor's CLI on the Paperclip host. The operator installs that runtime and it must be on PATH. What differs is what runs locally: a CLI in their case, a runtime and a persistent memory store in this one.

Does switching an adapter change what the agent can do, or only where inference runs? Both. The adapters differ in capability, not just hosting location. hermes_local brings the Hermes runtime's own built-in tool registry and its persistent memory store, sized and sourced in the hermes_local section above; codex_local is optimised for code generation where claude_local focuses on reasoning and ambiguous-input tolerance.

What is the difference between opencode_local and Manifest? opencode_local is the adapter; Manifest is an optional router you wire in front of it. You can run opencode_local without Manifest. If you want request-time routing across a provider pool, add Manifest. See the manifest-auto-routing guide.

---

A note on what has been checked here, and what has not. This page has been re-read three times against Paperclip's own documentation. The first pass was scoped by location; the second and third were scoped by claim, because scoping by location is what left a wrong table cell standing beside a corrected one. The third pass is why that matters twice over: the claim it corrected stood in three cells of one table row.

On 2026-09-16, two locations were re-read and corrected: what claude_local and codex_local run on the operator's host, in the self-hosting answer above, and where codex_local sends inference, in the comparison table.

On 2026-09-20, five claims about claude_local were re-read wherever they appear on this page, and every one was corrected. That claude_local is Paperclip's default adapter: the documentation names no default adapterType — it states other create-time defaults and not this one — gives claude_local and codex_local the same "Selectable (recommended)" availability tier, and calls the adapter picker a decision made at hire time, so this page now says recommended and most commonly used, which the documentation does say. What it does not say is that no default exists anywhere. That the documentation names none is what was checked; whether the adapter picker arrives with a value already selected is not documented either way, so this page no longer asserts it. That it is the lowest-setup path: no page ranks adapters by setup effort, and both local adapters require a vendor CLI on the host, so the ranking is gone rather than restated. That configuring an agent is sufficient to run one: Claude Code must be installed on the Paperclip host and on PATH, with auth configured — an Anthropic API key, Bedrock settings, or Claude subscription login, the three modes the documentation names — and the prose, the setup-effort row and the recommendation bullet now all say so. That Anthropic hosts and serves the model, stated flat: AWS Bedrock is a documented path where it does not — the adapter supports Bedrock settings as one of the three auth modes, and the documentation has the adapter offering region-qualified Bedrock model ids where it detects Bedrock — so the prose and the table row now carry that qualification the way the codex_local row already did. An earlier draft of this correction also named a redirected ANTHROPIC_BASE_URL as such a path. It is not one: the documentation names that variable once, under model discovery, as where the adapter looks up the model list, and no page says run traffic follows it. It has been dropped rather than left standing in a row about where inference runs. And which model tiers this adapter offers: the pages that enumerate model choices for it name Opus and Sonnet, the adapter reference adds Fable, and none of them names Haiku, so Haiku has been dropped rather than left as an inference about our own product. That last negative was run across the whole documentation site rather than a sample — one occurrence of "Haiku" in 259 pages, in a research skill's topic taxonomy, and none on any page that enumerates model choices for this adapter. Sources, all read 2026-09-20: the Claude Code adapter reference, the adapters overview, the agents API reference, the first-agent walkthrough, the agent-adapters guide, the agents guide, and the provider-key rotation how-to.

What that second pass does not cover: five claims, not the page. Anything here that is not one of those five claims about claude_local was not re-read on 2026-09-20 — the hermes_local, codex_local and opencode_local sections, the memory and cost rows of the comparison table, and the remaining FAQ answers. The memory row has since been re-read, by the third pass below; the cost row has not. The Hermes tool-registry figures earlier on this page carry their own note and are outside all three passes.

On 2026-09-25, a third pass covered one claim: that claude_local, codex_local and opencode_local treat every heartbeat as a fresh start and throw their context away when the run closes. They do not. Paperclip's adapter reference gives each of the three a session-persistence section — claude_local "stores the Claude Code session id and resumes it on the next heartbeat when the working directory still matches"; codex_local "preserves the previous_response_id chain so heartbeats can continue the same conversation instead of starting fresh each time"; opencode_local resumes with --session when the stored session cwd matches the current one. The adapters overview says the same from the other direction: it names session persistence or session resume for seven of the nine selectable built-in adapters, these three among them. So the fresh-start framing is gone from the hermes_local section above and from three cells of the memory row.

What has not changed is that row's answer, and the reason is the distinction the old copy had collapsed. Session resume is conversation continuity: the transcript comes back. A memory store is knowledge the agent writes for itself and retrieves later. They are not the same capability, and the overview's own adapter table credits hermes_local with persistent memory and no other adapter with it. So the others carry the transcript forward and hermes_local carries knowledge forward, which is a narrower claim than this page used to make. Sources, read 2026-09-25: the adapters overview, the Claude Code adapter reference, the Codex adapter reference and the OpenCode adapter reference. One claim, checked in every location it appears on this page rather than at the one line it was reported on — and nothing else on this page was part of the 2026-09-25 pass.

Three qualifiers those pages state, recorded here rather than worked into the copy. Resume is keyed to the working directory: move it between heartbeats and the adapter starts a new session instead. If the adapter cannot resume, it falls back to a fresh session automatically. And a session can be reset deliberately. None of them rescues the sentence this pass removed — that sentence said the context is discarded every run, and what the documentation describes is resume with exceptions, which is a different thing.

All three passes were documentation reads on a date, not checks against a release. The Paperclip documentation site publishes no version indicator on those reference pages, so what they state is current as of the date they were read rather than tied to a release number, and that date is the strongest stamp those pages carry. The site does publish a versioned changelog elsewhere, and one claim stated above can be dated by it: that changelog records the adapter's live model discovery — the /v1/models lookup and the Bedrock model ids — under v2026.529.0. Nothing else here was drawn from the changelog, and the remaining claims carry their read-date rather than a release number. Whether the changelog could date any of them was not checked. Read, not run: nothing was installed or executed for any of the three, and the corrections rest on those documentation reads. The third pass is the one read more than once — the adapters overview and the Claude Code and Codex references were read on 2026-09-17 and again on 2026-09-25, and said the same thing both times; the OpenCode reference was read once, on 2026-09-25. Two reads of a documentation page are still two reads of a documentation page. Nothing here was verified by running it.

Get on the list

I am building Paperclip Blueprints in the open, and the adapter decision above is exactly the kind of configuration choice the Blueprints are designed to make for you. Picking the right adapter is one piece of standing up an agent company; once you've chosen, wiring it onto each agent is a few clicks in the Paperclip UI.

Subscribe below for more on running AI-native operations. Practical field notes on agents in production, straight to your inbox.