_ _ _ __
/ \ __ _ ___ _ __ | |_(_)/ _|_ _
/ _ \ / _` |/ _ \ '_ \| __| | |_| | | |
/ ___ \ (_| | __/ | | | |_| | _| |_| |
/_/ \_\__, |\___|_| |_|\__|_|_| \__, |
|___/ |___/
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.
Claude Code's hook injects the context digest automatically. Codex follows its installed AGENTS.md guidance and loads the same store.
Hooks track edits and shell commands as compact JSONL (auto-compacted, capped ~512 KB). Command failures are remembered and checked before a retry.
It runs agentify ctx note. Notes are verified on injection: a note referencing a missing file is flagged as possibly stale.
A short extractive handoff is created from tracked evidence at zero model cost. An LLM refinement is a budgeted opt-in.
Installs straight from GitHub
One-line installer
Checks Node 20+ and git, then verifies the CLI. Pin a ref with AGENTIFY_REF=v0.3.0.
Wire into a repo
Both install and uninstall are surgical — only content between the managed markers is touched. Your own CLAUDE.md and hooks are preserved.
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:
- src/pay/retry.test.ts (9 edits)
Failure memory
A command that failed in a previous session triggers a PreToolUse warning before the exact retry — so doomed migrations and deploys aren't run twice.
Decision log
ctx decision records durable trade-offs; ctx decisions "topic" answers “why did we choose X” later. With ctx share it's a team ADR log.
Stale-note flagging
Every file path in a note is checked against the working tree on injection. Missing paths are flagged in place so the agent re-verifies instead of trusting outdated memory.
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 in container isolation to catch anything that only looks like a win inside Agentify's own runner.
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.
Consent-gated & private
Metadata-only by default. Transcript bodies are never analyzed, command text never leaves memory, nothing is uploaded, and $0 AI spend. --dry-run previews exactly what would be read.
0–100 usage scorecard
Each session is classified by tool mix and matched to the weight class of the model that ran it. Heavyweight-on-featherweight work is flagged overkill — “a gun at a fist fight” — as a delegation candidate.
Self-contained report
An Agentify-themed HTML brief: headline totals, filterable per-session rows, recommendation cards, an API-equivalent list-price estimate (never spend), and a privacy receipt of exactly what was read.
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 server is part of the CLI, no extra dependencies.
The runtime floor for the CLI.
Context is per-checkout; worktrees each get their own store.
Claude Code for hooks, or Codex for guidance-driven tracking. Anything else via MCP or the plain CLI.