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. Most companies start with claude_local and never need to look further. But 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 adapter decision starts to matter. This page maps it.

The four adapters

claude_local: hosted Claude, lowest setup

claude_local runs the agent on a hosted Claude model via Anthropic. The model is set in the agent's adapter config, and the available tiers include Fable, Opus, Sonnet, and Haiku. Anthropic handles hosting and serving; you configure an agent and it runs.

This is the default adapter and the lowest-setup path. 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. Unlike claude_local and codex_local, which treat each heartbeat as a fresh start (context assembled from Paperclip's task records and then discarded), 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 30+ built-in tools, expanding the problem classes it can address. The trade-off: memory operations add to runtime cost, and you run the Hermes runtime on your own infrastructure.

hermes_local is model-agnostic: it runs Claude, open-weight models, or a fully local model, so you get persistent memory and the 30+ tools 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.

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

Recommendation by use case

• Least setup, general purpose: claude_local. Configure an agent, pick a Claude model tier (Fable, Opus, Sonnet, or Haiku), run. This is the default and 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 is the default when I create a new agent? claude_local. All Paperclip agents use it by default, and it is the lowest-setup path.

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 are the fully-managed paths where you run no runtime of your own.

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 includes 30+ built-in tools not available on claude_local; 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.

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.

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