MIT Licensed  ·  4,330+ Ecosystem Tests  ·  Python 3.12+

H4H: Harness for the Harness

Claude Code is Anthropic's harness for the LLM. AgentiHooks is your harness for Claude Code. You don't serve the AI — the AI serves you.

Operator (you)
↓
AgentiHooks H4H layer
↓
Claude Code LLM harness
↓
Claude raw model
Take Control View on GitHub
pip install agentihooks

What the ecosystem gives you

Nine capabilities across four open-source layers. Start with one, add more as you need them.

🛡️

Guardrails

Secret scanning, retry circuit breaker, token budgets, CLAUDE.md sanity guard.

AgentiHooks
🚀

Fleet Control

Fire-and-forget dispatch, background jobs, plan-then-execute, session resume.

AgentiBridge AgentiCore
🧠

Memory

Session indexing, semantic search, knowledge catalog, context restore across sessions.

AgentiBridge
📊

Observability

3-line statusline, token monitor, context audit, OTEL + Langfuse telemetry.

AgentiHooks
📦

Agent Mode

Purpose-built containers with completions API, notification streaming, session registry.

AgentiCore
🌐

OpenAI Compatible

Standard /completions endpoint for agent containers. Works with any client.

AgentiCore
⚡

Raw Files

Works standalone — hooks on raw Claude Code files. No MCP server needed.

AgentiHooks
📁

Bundles

Portable dotfiles for Claude Code — profiles, skills, agents, rules. Clone and init.

AgentiHooks
🔧

MCP Tools (opt-in)

69 tools across 3 servers — disabled by default, opt-in by category.

AgentiBridge AgentiHooks AgentiCore
🔎

Agentic Search

agentibridge search "<q>" spawns a headless one-shot that reasons over sessions, history, memory, and git — live tool-call stream, human-readable summary.

AgentiBridge
🤝

Agent-to-Agent Registry

A2A: agents register, heartbeat, and discover peers by capability — cross-machine, cross-client. Redis-backed with file fallback.

AgentiBridge
🔄

Cross-Project Handoff

Seed a primed conversation in any target project with structured context (summary, decisions, next steps). Operator resumes with one command.

AgentiBridge
📢

Fleet Broadcast

PA system for your AI workforce. Push info / alert / critical messages to every active Claude Code session — targeted by channel, TTL-bounded, AI-assisted via emit.

AgentiHooks
💰

Cost & Context Intelligence

4-level token compression with a safety-preserving mask, context refresh every 20 turns, tool-memory replay of past errors, context audit. Defeats attention decay; cuts token spend.

AgentiHooks
🧠

Brain Adapter

Pluggable knowledge pump — hot arcs, operational memory, live ops signals injected into agents via broadcast channels. Your fleet thinks with shared context.

AgentiHooks

The Agenti Ecosystem — Four layers, one operator

🧠

AgentiBridge — The Brain

"What are my agents doing, and how do I command them?"

Agnostic MCP-first fleet control plane. 30 MCP tools: session indexing, semantic search, agentic agent_search, dispatch, cross-project handoff, and an A2A agent registry. Any MCP client, any automation.

⚙️

AgentiCore — The Engine

"How does the agent run?"

Dual-purpose execution engine with 14 MCP tools. Standard mode: clone repo, run Claude, create PR. Agent mode: containers with completions API.

🛡️

AgentiHooks — H4H

Harness for the Harness

Claude Code harnesses the LLM. AgentiHooks harnesses Claude Code. Four pillars: Identity (profile chaining), Guardrails (8+ by default), Context Intelligence (brain adapter, refresh, token compression), and Fleet Command (broadcast to every active session).

📦

AgentiHub — The Library

"Who is this agent?"

Self-contained agent packages with system prompts, MCP configs, eval harnesses, and startup scripts. Git clone and deploy — no build step required.

Install each layer independently

Every component is a separate pip package with its own init. Install one, install all three — there is no "full stack" single-command bundle. Pick the tab that matches the job at hand; the three on the right add AgentiBridge-specific options on top of Tab 2.

Terminal — AgentiHooks only (no Bridge, no Core) 
$ git clone https://github.com/The-Cloud-Clock-Work/agentihooks
$ cd agentihooks
$ uv venv ~/.agentihooks/.venv
$ uv pip install --python ~/.agentihooks/.venv/bin/python -e '.[all]'
$ agentihooks init

Guardrails, lifecycle hooks, statusline, profiles + profile chaining, brain adapter, fleet broadcast, token compression for context intelligence. Runs on raw Claude Code — no MCP server, no databases. Requires uv for the dedicated venv. Does not pull AgentiBridge or AgentiCore — install those separately if you need them.

Terminal — AgentiBridge only (no Hooks, no Core) 
$ pip install agentibridge
$ agentibridge install

Native Python service via systemd. Adds session indexing, semantic search, agent_search, dispatch, A2A registry, handoff, and knowledge catalog. Optional Redis + Postgres sidecars for caching and embeddings. Does not pull AgentiHooks or AgentiCore — they are independent packages.

Terminal — AgentiBridge app natively, databases in Docker 
$ pip install agentibridge
$ docker compose up -d   # redis + postgres sidecars only
$ python -m agentibridge

v0.5.0 ships AgentiBridge as a pip package only — there is no agentibridge container image anymore. The compose file only provisions Redis + Postgres sidecars (caching + pgvector embeddings). Skip Docker entirely and the app will fall back to filesystem-only storage.

Terminal — AgentiBridge systemd + native cloudflared 
$ pip install agentibridge
$ agentibridge install
$ agentibridge tunnel setup

Systemd user services + Cloudflare Tunnel (native cloudflared, not Docker). OAuth 2.1 with PKCE for claude.ai. Zero inbound ports. Still only installs AgentiBridge — combine with Tab 1 (Hooks) or Tab 5 (Full ecosystem) for guardrails on top.

Terminal — all three components, installed independently 
# 1. Hooks — from source (requires uv)
$ git clone https://github.com/The-Cloud-Clock-Work/agentihooks
$ cd agentihooks && uv venv ~/.agentihooks/.venv
$ uv pip install --python ~/.agentihooks/.venv/bin/python -e '.[all]'
$ agentihooks init && cd ..

# 2. Bridge — from PyPI
$ pip install agentibridge
$ agentibridge install

# 3. Core — from source (optional; background execution / agent containers)
$ git clone https://github.com/The-Cloud-Clock-Work/agenticore
$ cd agenticore && pip install -e .

Three separate installs because the three components are truly independent — each one runs standalone and none pulls the others as a dependency. Run all three and you get: guardrails + fleet broadcast + token compression (Hooks)  ·  session search + dispatch + A2A + handoff (Bridge)  ·  background execution + agent containers (Core).

1

Pick the component you need

Hooks, Bridge, Core — independent packages. There is no bundle install; each one serves a distinct job.

2

Wire it to Claude Code

Hooks auto-installs into ~/.claude/settings.json. Bridge exposes MCP over stdio or HTTP — add the URL to your client.

3

Add more layers as you go

Start with Hooks for guardrails. Add Bridge when you want cross-session search and fleet dispatch. Add Core when you need background agent containers.

30 AgentiBridge Tools
25 AgentiHooks Tools
14 AgentiCore Tools
4,330+ Tests

Two different paths to controlling AI

Anthropic's stack gives you a beautiful interactive experience — one session, one client, one vendor. AgentiBridge is the opposite: an agnostic MCP-first fleet control plane you can wire into any automation, any client, any agent.

Dimension Interactive native (Anthropic ecosystem) Fleet control plane (AgentiBridge)
Conversation model Direct, interactive — a human drives one live session Indirect — dispatch, handoff, agent-to-agent, asynchronous
Surface Claude app / claude.ai / Remote Control (Anthropic-hosted) Any MCP client + CLI + REST (Claude, ChatGPT, Grok, your automation)
Scope One session at a time, one vendor Entire fleet: many agents, many projects, many machines
Automation fit Human-in-the-loop Scripts, CI/CD, cron, A2A discovery, background jobs
Hosting Anthropic infrastructure Self-hosted, your data, MIT licensed
Works together? Yes — the interactive native tools and AgentiBridge are complementary, not competitive. Use both.

The honest pitch: you won't have a rich interactive conversation through AgentiBridge — that's not what it's for. You will have indirect control: dispatch tasks, hand off context across projects, let agents discover and call each other, drive the whole thing from any MCP client or a shell script. If your workflow is one human + one session, stay in the native tools. If your workflow is a fleet, wire AgentiBridge into it.

Fleet Control Plane · MCP-first · Agnostic

AgentiBridge — The MCP-first fleet control plane

30 MCP tools across 6 surfaces: Foundation, AI-Powered (incl. agent_search), Dispatch + Plans, Knowledge Catalog, Cross-Project Handoff, and the A2A Agent Registry. Every session indexed. Every transcript searchable. Every task dispatchable. Every agent discoverable.

v0.5.0 — pip package only: no app container image, no Docker noise. One pip install, one env file (~/.agentibridge/agentibridge.env), one systemd unit. Redis + Postgres are optional sidecars; everything works filesystem-only out of the box.

Secure remote access: Cloudflare Tunnel provides zero-inbound-port connectivity. OAuth 2.1 with PKCE for claude.ai. API key auth for programmatic access.

Explore AgentiBridge
AgentiBridge architecture — Remote Host connects through Cloudflare to Claude Session Network
Execution Engine

AgentiCore — Dual-Purpose Execution Engine

Standard Mode: Client sends task — clone repo, materialize profile, run Claude, create PR, cleanup. Fire-and-forget background orchestration.

Agent Mode: Purpose-built containers with OpenAI-compatible completions API, notification streaming, and session registry. Deploy agents that run as services.

Explore AgentiCore
Terminal 
$ agenticore dispatch \
    --task "Refactor auth module to use JWT" \
    --repo ./my-project \
    --background

✓ Job dispatched: job_a8f3c2e1
✓ Status: running
✓ Monitor: agenticore status job_a8f3c2e1
H4H — Harness for the Harness

AgentiHooks — Your harness for Claude Code

Claude Code is Anthropic's harness for the LLM. AgentiHooks is your harness for their harness. You don't build a new engine — you build the steering wheel. Four pillars: Identity, Guardrails, Context Intelligence, and Fleet Command. 25 MCP tools, 11 lifecycle hooks, brain-adapter integration, token compression, broadcast-to-fleet — standalone on raw Claude Code files.

⚡
All MCP tools disabled by default. You opt in by setting MCP_CATEGORIES in your config. Lifecycle hooks, statusline, and guardrails work immediately — no categories needed.

8 bundled categories

aws email messaging storage database compute observability utilities

Opt in via MCP_CATEGORIES in ~/.claude.json. Allowlist specific tools with ALLOWED_TOOLS.

🛡️
Built-in guardrails + cost controls: Token compression (4 levels, 30-50% context reduction with safety mask), retry circuit breaker (5 fails → error-researcher, 10 → hard block), secret scanning, file-read dedup, bash-output filter, branch/version guard, CLAUDE.md sanity, 3-line statusline, tool-memory replay, context refresh every 20 turns.
📢
Fleet Broadcast — no other tool does this. Push a message to every active Claude Code session simultaneously. Three severities (info / alert / critical) with different redelivery cadences, channel subscriptions for targeted delivery, TTL bounds, and an AI-assisted agentihooks broadcast emit mode sandboxed to Claude Haiku.
🧠
Brain Adapter. Pluggable source that pumps operational knowledge — hot arcs, live ops signals, operator intent — into every agent via the broadcast channel. The fleet works from shared context, not stale local memory.
📁
Bundles — portable dotfiles for Claude Code. A bundle is a version-controlled repo that configures your entire Claude Code environment: profiles, skills, agents, rules, and MCP settings. Clone it on any machine, run agentihooks bundle link + agentihooks profile use <name>, and your setup is restored identically. Create one bundle for your team, or many for different contexts. You can even dispatch bundle creation as a background task via AgentiBridge.

See the reference bundle →
Customize with bundles, not forks. Install via pip install agentihooks — add your own profiles, skills, agents, and rules in a bundle repo. Keep agentihooks updated without merge conflicts. Fork only if you want to contribute upstream.
AgentiHooks Docs
~/.claude.json — hooks-utils MCP server
// All tools disabled by default
// Opt in by category:
"env": {
  "MCP_CATEGORIES": "aws,email,observability"
}

// Or allowlist specific tools:
"env": {
  "MCP_CATEGORIES": "utilities",
  "ALLOWED_TOOLS": "get_env,hooks_list_tools"
}

// Verify what's active at any time
✓ Call hooks_list_tools() inside Claude Code
Agent Library

AgentiHub — Your Agent Library

Self-contained agent packages. Each agent ships as a directory with its identity config, deployable package, and evaluation harness. AgentiCore clones and deploys them directly — no compilation, no build step.

Define an agent's identity once, version it in Git, and deploy anywhere. From content publishers to security auditors — every agent is a package.

Starter templates:

agentihub-example — Reference agent packages with publishing agent
agentihooks-bundle-example — Reference bundle with profiles, skills, agents, rules

Explore AgentiHub
agents/publishing/ — real agent from AgentiHub 
agents/
  publishing/
    ├── agent.yml           # identity, model, permissions
    ├── evaluation/
    │   ├── eval.yml        # evaluation config
    │   └── cases/          # test cases
    └── package/
        ├── CLAUDE.md       # agent instructions
        ├── system.md       # system prompt
        ├── .mcp.json       # MCP server config
        ├── .claude/
        │   └── settings.json
        └── runners/        # execution scripts
The Complete Picture

How it all connects

The operator sits at the top. AgentiHooks (H4H) wraps Claude Code. AgentiBridge dispatches to AgentiCore. Core fetches packages from Hub. Every layer answers to you.

AgentiBridge
Observe, search, dispatch — the user-facing control plane
↓ sends task
AgentiCore
Execution engine — receives tasks, orchestrates jobs, runs agents
↓ fetches package
AgentiHub
Agent identity — prompts, configs, eval harnesses
↓ loads guardrails
AgentiHooks
Lifecycle hooks, MCP tools, secret scanning
↑ feeds profiles & config
Bundle
Portable environment — profiles, skills, agents, rules

30 AgentiBridge MCP tools at your fingertips

Every tool you need to search, manage, dispatch, hand off, and orchestrate agents across projects and machines. Plus 25 more from AgentiHooks and 14 from AgentiCore.

Foundation

list_sessionsBrowse all indexed sessions
get_sessionRetrieve full session transcript
get_session_segmentFetch specific conversation segment
get_session_actionsList tool calls and actions taken
search_sessionsKeyword search across sessions
collect_nowTrigger immediate transcript indexing

AI-Powered

search_semanticNatural language search with embeddings
generate_summaryAI-generated session summaries
agent_searchHeadless one-shot recon over sessions + git + memory

Dispatch & Plans

restore_sessionResume a previous session
dispatch_taskFire-and-forget background task
get_dispatch_jobCheck job status and results
list_dispatch_jobsAll jobs with status filter
plan_taskCreate implementation plan
execute_planRun a plan as a coding job
get_dispatch_planRetrieve plan content
list_dispatch_plansAll plans with status filter

Knowledge Catalog

list_memory_filesBrowse memory files by project
get_memory_fileRead specific memory file contents
list_plansView generated implementation plans
get_planRead full plan details
search_historySearch across prompt history

Handoff

list_handoff_projectsDiscover target projects for handoff
handoffSeed a primed conversation in any project

A2A Agent Registry

register_agentAnnounce an agent to the fleet
heartbeat_agentKeep-alive ping with status
deregister_agentRemove an agent on shutdown
list_agentsDiscover all registered agents
get_agentFetch a specific agent's metadata
find_agentsFilter by capability across the fleet

Frequently asked questions

Four open-source components that work together: AgentiBridge (30 MCP tools for session search, dispatch, handoff, and the A2A agent registry), AgentiCore (14 MCP tools for background execution and agent containers), AgentiHooks (11 lifecycle hooks, 25 MCP tools, guardrails), and AgentiHub (reusable agent packages). Each layer is independent — start with one and add more as you need them.

No. Each component is an independent pip package with its own init — none of them pull the others as a dependency. Start where your pain is: AgentiHooks for guardrails + fleet broadcast + token compression (from source via uv, no MCP server needed); AgentiBridge for session search + dispatch + A2A + handoff (pip install agentibridge); AgentiCore for background execution + agent containers; AgentiHub for versioned agent packages. Add more layers when you need them.

No — different paths. The native Anthropic tools give you a rich interactive experience in one session. AgentiBridge is an agnostic MCP-first fleet control plane for indirect control: dispatch, handoff, A2A, automation. You won't have a Claude-web-quality conversation through AgentiBridge — that's not the point. You will wire it into CI, let agents discover each other, hand off context between projects, and drive the whole thing from any MCP client. Use both.

Bundles are portable, version-controlled repos that configure your entire Claude Code environment — profiles, skills, agents, rules, and MCP settings. Clone a bundle, run agentihooks bundle link, and your setup is restored identically on any machine. See agentihooks-bundle-example for a reference implementation.

Agent Mode is AgentiCore's container-based execution. Instead of cloning repos and making PRs, it loads a pre-configured agent package from AgentiHub and exposes an OpenAI-compatible /completions API. Agents run as long-lived services with notification streaming and session continuity.

No. pip install agentihooks works with zero dependencies. pip install agentibridge && python -m agentibridge works with filesystem-only storage. Add Redis for caching and Postgres for semantic search when you need them — agentibridge install wires them up via optional Docker sidecars.

No. No telemetry, no SaaS. Cloudflare Tunnel is opt-in — your transcripts stay local. Read every line of the source code.

Claude Code CLI, claude.ai, ChatGPT, Grok, and any MCP-compatible client. Run agentibridge connect for ready-to-paste configs.

Your AI. Your rules. Your harness.

H4H — from guardrails to production agents, under operator control.

Take Control
pip install agentihooks