claude-code-harness

Claude Code Harness

Turn an agent idea into a real harness blueprint.

claude-code-harness is a public skill and plugin package for developers who want to design the runtime around an agent, not just the prompt inside it.

It is inspired by Claude Code's harness design and generalized into a reusable pattern language for building agentic systems with clearer request assembly, tighter control loops, safer tool boundaries, and stronger recovery behavior.

This project is unofficial. It is not affiliated with Anthropic.

What a harness is

A harness is the layer that turns a model into an operating system for work.

It decides:

• how a request is assembled
• how a turn progresses
• what tools exist and how they are governed
• what memory survives which boundary
• what gets logged, resumed, compacted, or escalated
• how a human can still understand and control the system

flowchart LR
    U["User / Host"]
    RA["Request Assembly<br/>instructions + context + tools + history"]
    TL["Turn Loop<br/>gather → think → act → verify"]
    TP["Tool Plane<br/>capabilities + permissions"]
    MP["Memory Plane<br/>context + durable memory + compaction"]
    TR["Transcript / Recovery<br/>logs + resume + continuity"]
    EP["Extension Plane<br/>plugins + MCP + subagents"]

    U --> RA --> TL
    TL --> TP
    TL --> MP
    TL --> TR
    TP --> TL
    MP --> TL
    TR --> TL
    EP --> TL

Why this repo exists

Most agent projects still stop at one of these weak states:

• a prompt with a tool list
• a loop with no governance
• memory with no boundaries
• autonomy with no control surface
• retries with no recovery model

This repo is meant to force a higher bar.

The question it keeps asking is:

What is the harness here, exactly?

What this skill does

This repository currently ships one skill:

• claude-code-harness

The skill helps you produce a harness blueprint for an agentic system. It pushes you to specify the runtime planes that are usually hand-waved away.

Plane	What the skill forces you to define
Request assembly	instruction sources, system/user context, tool exposure, transcript normalization
Turn loop	gather, decide, act, verify, stop/retry/escalate
Tool plane	capability contracts, permission gates, success criteria, rollback story
Memory plane	active context, retrieval, durable memory, compaction
Recovery plane	transcript, resumability, partial work, continuity
Human control	approvals, visibility, interruption, auditability
Extension plane	plugins, MCP, subagents, future expansion points

When to use it

Use this skill when you need to answer questions like:

• What is the runtime shape of this agent?
• How should we assemble each model request?
• What are the real boundaries between loop, tools, memory, and persistence?
• Where should permissions and approvals live?
• How would this system recover from interruption or partial failure?

Do not use it when you only need:

• a better prompt
• a generic product brainstorm
• a feature list for an AI app
• plain implementation tasks with no runtime design problem

How this differs from claude-code-philosophy

claude-code-philosophy is broader. It helps people design better agentic products in general.

claude-code-harness is narrower and sharper. It is specifically about the runtime architecture around the model:

• request assembly
• control loop
• capabilities
• memory boundaries
• transcript and recovery

If claude-code-philosophy asks “what kind of agent product should this become?”, this repo asks “what harness must exist for that product to actually work?”

What a good output looks like

When the skill is doing its job, the result should look like a blueprint, not a pep talk.

The default output shape includes:

1. system goal and delegation boundary
2. harness layers
3. request assembly design
4. turn loop design
5. tool runtime and permission boundaries
6. memory and context strategy
7. transcript and recovery model
8. extension surfaces
9. build order

Quick install