Harness Hub

A field guide · Checked Oct 29, 2026

Build your own harness

A guide for people building a DIY agent harness. Data checked on 2026-10-29.

You don't need to write a harness to own one. The agent loop is a commodity now; what makes a harness yours is the layer of skills, plugins, hooks, memory and tools you put around it, and the sandbox and measurements you wrap it in. This guide walks the layers, names open-source pieces for each from the directory, suggests three starter stacks and ends with a checklist for vetting anything you install. For the operational side (choosing, sandboxing and upgrading a big harness), see the open-source harness best practices guide.

Every pick links to its directory page, with stars, license and sources. Browse all of them on Skills, Plugins & Mods.

The layers of a harness

A harness is everything around the model. Built bottom-up, it has eight layers. You rarely write any of them from scratch: each has open-source pieces in this directory, and the Skills, Plugins & Mods section collects the add-ons for the middle layers.

LayerWhat it doesOpen-source picks
1. Agent loopCalls the model, runs tools, feeds results backClaude Code, Codex, opencode, Gemini CLI, Pi, or an SDK such as Claude Agent SDK
2. SkillsInstructions and scripts the agent loads when a task needs themAgent Skills spec, Anthropic Skills, Superpowers, Matt Pocock's skills
3. Plugins, hooks, subagentsInstallable bundles, deterministic checks around tool calls, delegated workersClaude plugins directory, wshobson/agents, TDD Guard, CC Safety Net
4. Memory and contextWhat survives a session, and what is kept out of the windowclaude-mem, agentmemory, Context Mode, planning-with-files
5. MCP toolsConnections to the outside world over one protocolMCP, reference servers, GitHub MCP, Playwright MCP
6. SandboxWhere tool calls run, and what they can reachE2B, container-use, Sandcastle, NemoClaw
7. Evals and observabilityTraces, costs and tests that tell you whether a change helpedLangfuse, Phoenix, promptfoo, Inspect, ccusage
8. OrchestrationMany agents, many models, one workflowoh-my-claudecode, Claude Squad, Claude Code Router, CC Switch

Skill, plugin and mod are the words this directory uses for layers 2 to 4 and 8. A skill is instructions the agent loads (usually a SKILL.md folder). A plugin is installed through a harness's own plugin system or marketplace. A mod changes how the harness itself behaves: hook packs, workflow layers, config packs, routers.

Assembling it from open-source pieces

Start with a loop you can read. If you want to understand the loop before you depend on one, learn-claude-code builds a nano harness from zero. Pi is the minimal end of the real ones; Armin Ronacher notes it "only has four tools: Read, Write, Edit, Bash." Deep Agents is the batteries-included end. Most DIY builders keep a stock agent loop and customise the layers above it.

Add skills before you add code. The Agent Skills format is a folder with a SKILL.md (name, description, instructions) plus optional scripts and assets. Agents load it by progressive disclosure: only names and descriptions at startup, the full file when a task matches. That is why skills are the cheapest layer to try. The skills CLI (npx skills add owner/repo) installs them into the project or globally for the agents you pick, and AGENTS.md is the matching standard for repository-wide instructions.

Use hooks for rules that must hold. A rule in a prompt can be ignored; a hook runs every time. TDD Guard enforces test-first work through Claude Code hooks, and CC Safety Net and Destructive Command Guard block destructive git and filesystem commands before they run. Claude Code Hooks Mastery is a reference for the hook lifecycle. Package what works as a plugin, as Compound Engineering and wshobson/agents do across several harnesses.

Treat context as a budget. Context Mode keeps raw tool output out of the window (its README cites 315 KB reduced to 5.4 KB). planning-with-files keeps the plan on disk so it survives compaction, and claude-mem or agentmemory carry decisions across sessions.

Connect tools over MCP, narrowly. The Model Context Protocol is the default tool bus. Prefer servers with a deliberately small tool surface, and load tool definitions on demand where your client supports it (see §5).

Put the whole thing in a box, then measure it. Pick a sandbox (E2B, container-use, or your harness's own, such as the Claude Code sandbox), trace runs with Langfuse or Phoenix, and keep a small eval set in promptfoo or Inspect. ccusage reads Claude Code and Codex logs for token use and cost, which is the fastest way to see what a new plugin really costs.

Orchestrate last. Once one agent works, Claude Squad runs several in isolated git workspaces, Claude Code Router gives them one local endpoint with fallback models, and oh-my-claudecode or oh-my-codex add team workflows on top of a single harness.

Three starter stacks

These are starting points, not endorsements. Swap any piece for one from the same layer on Skills, Plugins & Mods.

LayerSolo developerTeamAlways-on personal agent
Agent loopClaude Code or opencodeThe harness the team already pays for, plus Codex as a second opinionHermes Agent or OpenClaw
SkillsSuperpowers or Matt Pocock's skillsShared, pinned skills from a private registry such as SkillHub; Spec Kit or OpenSpec for specsA few skills you wrote or read line by line
Plugins and hooksClaude HUD to see context use; TDD GuardCC Safety Net in the repo; Ruler or rulesync to keep rules the same across agentsFailproof AI policies on tool calls
Memory and contextContext Mode, planning-with-filesBeads as shared task memoryagentmemory (scrubs secrets, lets you forget)
ToolsPlaywright MCP, Context7GitHub MCP with read-mostly scopesOnly the MCP servers each task needs
SandboxYour harness's sandbox, or container-useSandcastle or E2B per taskNemoClaw or a dedicated VM; never an exposed control plane
Evals and costccusageLangfuse traces and a promptfoo suite in CISpend caps and traces before autonomy

Vetting checklist for skills and plugins

A skill is text your agent will follow and often scripts it will run; a plugin can add hooks that execute on every tool call. Both run with your agent's access. Before installing anything third-party:

  1. Pin it. Install a tagged release or a commit SHA, never a moving branch, and re-review on every bump. Big harnesses ship several releases a week (see the best-practices guide); add-ons move just as fast.
  2. Read the SKILL.md and every script. Look for instructions to fetch URLs, read dotfiles, disable confirmations or run bundled binaries. A plugin's hooks are shell commands: read them like a postinstall script.
  3. Scan it. SkillSpector checks skills for 71 vulnerability patterns across 17 categories, including prompt injection, exfiltration and supply-chain risks, and outputs SARIF for CI. Snyk Agent Scan covers agents, MCP servers and skills.
  4. Allowlist sources. Install only from repos or registries you have approved; a self-hosted registry such as SkillHub adds RBAC and audit logs. Public marketplaces have shipped malicious skills: secondary coverage reported 341 on ClawHub in early 2026 (counts unverified).
  5. Sandbox the agent, not just the tool. In Claude Code's sandbox, file tools, MCP servers and hooks run outside the boundary, so a plugin's hook is not confined by it. Hermes' security policy says its terminal backend does not confine code running in the agent's own process, including skills and plugins.
  6. Keep secrets out of context. Deny reads of ~/.ssh, cloud credentials and .env files, pass tokens through the environment of the tool that needs them, and prefer memory plugins that scrub secrets, as agentmemory does.
  7. Assume prompt injection. Skill text, tool descriptions and tool output are all model input. An agent with private data, untrusted content and a way to send data out is Simon Willison's "lethal trifecta"; remove one leg. MCP tool metadata can hide instructions too (tool poisoning).
  8. Give each add-on the least it needs. Narrow MCP servers over a raw shell, read-only scopes over write, and ask-rules (for example on git push) that prompt even inside the sandbox.
  9. Measure the cost. Note what a skill pack or plugin adds to every prompt before you keep it (see §5), and drop what you don't use.

What the community reports

From the sourced "What the community says" notes on the project pages. These are user reports, not our measurements.

TopicPros people reportCons people report
Claude Code as the baseRich harness features (subagents, skills, hooks, plugins, headless use); users report moving skills and memories to Codex in minutesHeavy context: one measurement found about 33k tokens sent before the prompt versus about 7k for opencode
opencode as the baseAny provider, configurable subagents, leaner prompt overhead and a plugin ecosystem (for example dynamic context pruning)No built-in sandbox; an October 2026 breach of a legacy system exposed BYOK provider keys stored in workspaces
Hermes Agent skillsCreates reusable skills from completed tasks; portable file-based memoryThe default load-out lists many skills (over 10k tokens just to list them); it can overwrite manual skill edits
OpenClaw skillsA large skill ecosystem and memory kept as files, so switching models is easyMalicious skills in the marketplace and prompt-injection risk; updates frequently break setups
MCP toolsThe de facto way to expose tools; narrow servers are safer than a raw CLI; deferred tool loading fixes much of the bloatEagerly loaded tool definitions eat context; tool poisoning makes each third-party server a supply-chain risk

Keeping your stack current

Add-ons change weekly. Sort Skills, Plugins & Mods by recent updates to see what moved, and filter by the harness you run. Harness Hub's own discovery job searches GitHub every day for new skills, plugins and mods and queues them for human review; nothing is listed until someone has checked it. Know one we missed? Suggest it.

When you update, re-run the checklist in §4 on the diff, and re-run your eval set before and after. If a plugin doesn't move your numbers, it's only adding context.

Sources

  1. Agent Skills specification (agentskills/agentskills)
  2. Anthropic Agent Skills repository
  3. Vercel Labs skills CLI
  4. Claude Code plugin directory (anthropics/claude-plugins-official)
  5. Claude Code sandboxing docs
  6. Hermes Agent SECURITY.md
  7. Armin Ronacher, Pi: the minimal agent
  8. NVIDIA SkillSpector
  9. Snyk Agent Scan
  10. iFlytek SkillHub
  11. Context Mode README (315 KB to 5.4 KB)
  12. agentmemory README (secret scrubbing)
  13. TDD Guard
  14. CC Safety Net
  15. Destructive Command Guard
  16. Simon Willison, The lethal trifecta
  17. Invariant Labs, MCP Tool Poisoning Attacks
  18. MCP Security Best Practices
  19. The Hacker News, 341 malicious ClawHub skills (secondary coverage; counts unverified)
  20. Hacker News: Claude Code harness features (skills, hooks, plugins)
  21. Hacker News: moving skills and memories between Claude Code and Codex
  22. Hacker News: 33k vs 7k tokens before the prompt (Claude Code vs opencode)
  23. Hacker News: opencode plugin ecosystem (dynamic context pruning)
  24. Hacker News: opencode BYOK key exposure
  25. Hacker News: Hermes default skills cost 10k+ tokens to list
  26. Kilo, OpenClaw vs Hermes: what Reddit says
  27. Hacker News: OpenClaw security model and malicious skills
  28. Hacker News: MCP as the standard for tools
  29. Hacker News: narrow MCP servers vs raw CLIs
  30. Hacker News: deferred tool loading
  31. Hacker News: MCP tool poisoning and supply-chain risk