_                    _   _  __
   / \   __ _  ___ _ __ | |_(_)/ _|_   _
  / _ \ / _` |/ _ \ '_ \| __| | |_| | | |
 / ___ \ (_| |  __/ | | | |_| |  _| |_| |
/_/   \_\__, |\___|_| |_|\__|_|_|  \__, |
        |___/                      |___/

Switch agents. Keep the repo's working memory.

Agentify keeps durable working context with the repository instead of trapping it inside one agent harness. Install once — from then on your coding agent drives it automatically.

Claude Code through lifecycle hooks, Codex through installed guidance, everything else through MCP. It carries forward explicit, compact project evidence — decisions, session summaries, failures, hot files — that should survive the switch.

One store. Every session picks up where the last left off.

agentify install --provider all wires both harnesses against one repo-owned .agentify/context/ store. No daemon, no database server, no per-command wrapping.

Installs straight from GitHub

Every command

All commands accept --json for machine-readable output — which is how agents are expected to call them.

Context arrives when it's relevant, not as a firehose

Sessions start with a one-line pointer, and each prompt is matched against the store — only related notes and files get injected, deduplicated per session. Ask about payment retries:

Prefer always-on? Set context.injection: digest in .agentify.yaml (or off to disable injection — tracking continues either way).

Shell work out to the model best suited for it

agentify install writes a routing table into .agentify.yaml mapping kinds of work to models. The guidance block teaches the agent to delegate instead of doing everything inline.

Every route carries a hard per-run ceiling — dollars, agent turns, and wall-clock — so no Agentify-initiated paid run is ever unbounded. If a route's CLI isn't installed, Agentify falls back to the other vendor at the same capability tier. Routing profiles (cost · balanced · performance) choose how to route inside those ceilings, fed by local agentify eval runs — never rewriting your config.

Does Agentify actually help?

Cost only means something next to task success. agentify eval runs the same task, prompt, pinned model, and budget through paired arms — agentify vs plain-safe vs plain-project — and grades each attempt with deterministic checks.

Every attempt runs in a disposable clone at the manifest's immutable base_ref with a hard per-attempt ceiling. Turn a run into a decision with agentify eval report --format html: per-arm pass rates with 95% CIs, cost per passing task, and a cost-quality frontier. A second harness (Harbor / Terminal-Bench 2.0) runs the same paired question across a 38-task container dataset, to catch anything that only looks like a win inside Agentify's own runner.

Every campaign, including the ones we lost

Each row is backed by committed receipts under evals/results/ — raw runs plus the report they produce — and CI fails if the current code stops reproducing them.

Against the same agent with no memory layer the result is consistent and large. Separately, against a memory-enabled competitor — Serena's code-intelligence MCP, given the same knowledge in its own native memories — 9/0 discordant. Against a hand-maintained CLAUDE.md memory bank holding the same knowledge, two campaigns found no significant difference, with the point estimate favouring the memory bank — published rather than buried. No leaderboard claims: this is Agentify's own context benchmark. Full tables, scope caveats, and a log of the numbers that moved down after review: docs/benchmarks.md.

Look at the session history you already have

Where stats and value report Agentify-owned telemetry, agentify analyze looks at the other side — your local Claude Code and Codex session history — and shows usage, tool patterns, and concrete, evidence-backed places where Agentify would have helped. Plus exactly one roast, because the data earned it.

Board to draft PR — you never invoke the workflow by name

The bundle installs as agent skills, and the agent matches them to plain requests. Triage the board, pick up an item, implement it in an isolated worktree, and raise a draft PR — on GitHub, GitLab, or Azure DevOps.

A catalog the agent matches to plain requests

Agentify bundles a catalog of agent skills — TDD, PR and commit workflows, board triage, refactor plans, and more. Install them per provider and scope; each skill declares when it applies, so the agent picks the right one from what you ask — you never invoke a skill by name. Browse the full catalog →

Scopes: --provider claude|codex|gemini|opencode · --scope project|global. The platform workflow bundles above install as these same skills.

Every other agent speaks MCP

Hooks are Claude Code-specific and AGENTS.md guidance is best-effort. For Cursor, Zed, Windsurf, Gemini CLI, or Claude Desktop, Agentify speaks MCP. The bundled stdio server supports legacy 2025-era clients and the stateless 2026-07-28 protocol with discovery, request validation, and cacheable tool lists.

Carry the full agent session through Agentify

ACP connects an editor to an agent. Agentify sits transparently in that transport, launches Claude or Codex downstream, and can add the same repo memory used by hooks and MCP without changing unknown protocol messages.

Both controls honor ctx pause and enforce a symlink-safe workspace boundary. ACP client registration is still manual; agentify install does not claim to edit editor-specific client config.