There are thousands, and more every week. The first thing that matters about a tool is which discipline it covers. If you cannot say which, you cannot say whether you need it.
Watch the portability. Whatever you store in a tool that only speaks to one agent is lost the day you switch agents — and you will switch.
Jump to a discipline
What each of these things is
Every entry in this catalogue carries a shape. It is not a decorative label: it decides how the thing is installed, who inherits it, and what happens the day you remove it. Two tools that cover the same discipline in different shapes are not interchangeable.
Harness
The program you work with the agent from: a terminal, an editor, an extension. It is not the model — the model only produces text — it is what turns that text into actions on your machine.
What it buys you
Three things you do not otherwise have. The loop: read, act, look at the result, decide again, instead of you copying and pasting between a chat window and your editor. The permission boundary: what runs on its own, what asks first, what never runs. And the extension points: where your rules, your skills and your subagents plug in. Without a harness there is no workflow to engineer, only a conversation you copy things out of by hand.
Index
A database of your code: which symbols exist, who calls what, which file depends on which. Built once and updated as you write.
What it buys you
Exact answers instead of searches. Asking who uses a function returns the list; finding the same thing by reading costs dozens of files and still does not prove you found them all.
Service
A process that runs separately and keeps something between sessions. The agent talks to it; the state lives on the service's side, not in the conversation.
What it buys you
Real persistence and, if it speaks an open protocol, the chance that next year's agent can read it too.
File
A text file in the repository holding rules, context or instructions. The simplest shape there is, and the one fewest people use seriously.
What it buys you
Inheritance without coordination. Whoever clones the project has it, without being told and without installing anything. It travels with the code and is reviewed in the pull request like any other change.
Protocol
A standard for agents to talk to external services, so that every agent-and-service pair is not its own bespoke adapter.
What it buys you
You write the integration once and every agent that speaks the standard uses it. That is the difference between one integration and N.
Procedure
A set of steps with an order and an exit criterion. You do not install it: you follow it.
What it buys you
A result that does not depend on who asked or how their day was going. It is the cheapest thing to adopt and the easiest to abandon.
Package
A procedure wrapped in a file the agent can load by itself: the steps, plus a description of when they apply. What you install is the package; what gets followed is the procedure inside it.
What it buys you
The procedure shows up without anyone remembering to invoke it, and costs no context until the task matches. The file travels; how it is discovered, loaded and ordered against others is the harness's business.
Workflow
A procedure already packaged and executable: phases, artefacts between them, and gates, with the commands already written.
What it buys you
The procedure gets followed without depending on anyone's memory. The cost is that it brings opinions with it, and some of them will not be yours.
Pattern
A known way of solving something that belongs to no product. Nothing to install, nothing to update.
What it buys you
The idea travels whole, because it belongs to no product. The wiring does not: every harness implements it its own way, and that part you rewrite when you move. In exchange it guarantees nothing: a pattern nobody applies is a nice idea.
01
Memory
What survives when you close the terminal?
Storing the decisions you make — and the reasoning behind each one — somewhere that still exists tomorrow and that any AI tool can read.
Engram
Gentleman ProgrammingService
Persistent memory for coding agents, with search, typed observations, and conflict detection between memories.
Problem, mechanism & fit
The actual pain
Yesterday's architecture decision evaporated when you closed the terminal, and tomorrow the agent will propose the option you already rejected.
How it works
Stores typed observations — decisions, fixed bugs, conventions, discoveries — scoped to a project, and exposes them over an open protocol so any agent can search them. When a new memory contradicts an old one it flags it instead of silently overwriting.
When it fits
When a project runs for months and decisions matter more than code. Conflict detection is what separates it from a notes file: a stale memory that is now false does more damage than none at all.
gbrain
Garry TanService
A Markdown knowledge base with hybrid search, an entity graph, and synthesised answers with citations.
Problem, mechanism & fit
The actual pain
Most note systems hand back a list of pages. You do not want pages: you want the answer, and you want to know what is missing.
How it works
Syncs Markdown repositories into a database with vector search. It combines semantic and keyword search with reranking, builds an entity graph with typed relations, and synthesises answers that cite their sources — including what it could not find.
When it fits
When the knowledge you need is not in the code: business context, people, decisions, research. To know what exists in the repository, a code index is the right tool.
claude-mem
Alex NewmanService
Memory that captures observations by itself, unprompted, and re-injects them at session start.
Problem, mechanism & fit
The actual pain
A memory that depends on the agent remembering to save is a memory that will forget to save.
How it works
A trigger records compressed observations after every action — bugs, decisions, discoveries — into a local database with semantic search. At session start, another trigger injects a project summary without the model having to ask.
When it fits
When you want passive capture and zero friction. The price is control: you capture everything, noise included. Explicit capture costs discipline but yields cleaner memories.
02
Context
What does it know about your world, right now?
Putting what actually exists within reach: your code, who calls what, and the docs for the library version you have installed.
CodeGraph
Colby McHenryIndex
An index of your code as a graph: symbols, who calls what, dependencies and blast radius.
Problem, mechanism & fit
The actual pain
Grepping and reading whole files to understand one function burns the window and still misses who calls it.
How it works
Indexes the repository as a graph of symbols and relations. One query returns the relevant source with line numbers, the call paths between symbols, and a summary of what breaks if you touch it — in a single round trip instead of a search-and-read loop.
When it fits
In any repository that no longer fits in one person's head. The gain is not only accuracy: the agent spends its context thinking rather than searching.
Context7
UpstashService
Pulls current, version-specific documentation for the library you are using straight into context.
Problem, mechanism & fit
The actual pain
The model learned a library's API at some point in the past. You have a different version installed. Out of that gap come the calls that look right and do not exist.
How it works
Connects as an external service and exposes two operations: resolve a library's identifier, and fetch its current documentation and examples for the right version.
When it fits
When you work with fast-moving libraries, or when the agent keeps insisting on an API that no longer exists. It connects in minutes and removes an entire cause of error.
03
Standards
What does “done well” mean on this project?
Writing the project's rules, conventions and procedures once, somewhere the agent reads on its own without being reminded.
AGENTS.md
Open standard, Agentic AI FoundationFile
A file in the repository holding the project's rules, which the agent loads on its own at startup. An open format read by a couple of dozen agents, from Codex and Gemini CLI to Cursor, Copilot and Devin.
Problem, mechanism & fit
The actual pain
Repeating “use pnpm”, “tests go here”, “don't touch that folder” in every conversation is pure waste, and it walks out when the team changes.
How it works
The agent reads the file at startup and prepends it to context. Tool-specific equivalents — CLAUDE.md in Claude Code, and others — are adapters around the same project knowledge: the contents are portable, while the filename, the loading rules and the precedence between several of them belong to the harness. It is the cheapest coverage there is and the most underrated: it costs an afternoon and depends on installing nothing.
When it fits
Always, and it is the first thing to do. The usual mistake is writing it as documentation for humans: these are executable orders, short and unambiguous.
Agent Skills
Anthropic, open standardPackage
Procedures packaged as a folder — instructions, scripts, resources — that the agent loads on its own when the task that needs them appears.
Problem, mechanism & fit
The actual pain
The agent solves the same task differently every time, and your team's correct way of doing it is not in its weights.
How it works
A directory with a SKILL.md at its root: instructions, plus a description of when they apply, plus whatever scripts and files the procedure needs. Loading is progressive — the agent holds only the name and description until a task matches, then reads the rest — so what an idle skill costs you is its description, not its contents.
When it fits
When a procedure repeats and has a right answer. It is the difference between asking for an outcome and teaching a method.
04
Capability
What can it touch, and what should it never be able to touch?
Giving it real access to what it needs — files, commands, external services — and setting explicit limits on what it does not.
Claude Code
AnthropicHarness
Terminal agent with declared permissions, hooks, subagents and skills; also on desktop, web and IDEs.
Problem, mechanism & fit
The actual pain
The model alone cannot read your repository or run your tests. Something has to build the loop and decide what it is allowed to touch.
How it works
Runs a loop over your project: reads, edits, executes and evaluates the result. Permissions are declared in a config file, hooks intercept actions deterministically, and subagents keep heavy work out of the main thread.
When it fits
When you want the loop in the terminal with fine control over permissions and automation. If you want assisted editing inside your editor, an IDE-integrated agent fits better.
Cursor
AnysphereHarness
An editor with the agent built into the editing surface.
Problem, mechanism & fit
The actual pain
Switching between terminal and editor breaks the thread when the work is mostly local editing.
How it works
An editor pairing repository indexing with an agent that edits in the same place you are reading the code, showing changes inline.
When it fits
When the work is mostly editing files and you want the diff where you are. For long multi-step tasks with many commands, a terminal agent gives more control.
Codex CLI
OpenAIHarness
OpenAI's terminal agent, with support for procedures and external services.
Problem, mechanism & fit
The actual pain
The same as any agent: the model needs hands.
How it works
A terminal agent loop over OpenAI models, with configurable approval modes and the ability to consume procedures and connected services.
When it fits
When you live in the OpenAI ecosystem. Worth knowing even if you do not use it: running two agents on the same task is the fastest way to see what the environment contributes and what the model contributes.
OpenCode
Open source communityHarness
An open source, provider-agnostic terminal agent.
Problem, mechanism & fit
The actual pain
Tying your whole workflow to one vendor's agent is a bet that the vendor stays ahead forever.
How it works
An open source agent loop that connects to multiple model providers, with agent and tool configuration held in the repository.
When it fits
When you want to swap models without swapping workflow, or you need to read and modify the environment itself.
Pi
EarendilHarness
A minimal harness: it runs agents in the terminal and brings nothing else. Whatever you need, you add.
Problem, mechanism & fit
The actual pain
Harnesses ship with opinions inside them — which permissions to ask for, how to split the work, which services to connect — and those opinions are not always yours.
How it works
A terminal with an interactive mode, scriptable output, an RPC protocol and an SDK to embed it. It extends through extensions, skills and prompt templates installed from npm or git. It routes to fifteen-plus providers and lets you switch model mid-session. Sessions stay in local files.
When it fits
When you already know which disciplines you want to cover and would rather build them than inherit somebody else's. If you are still working out what you are missing, a harness that brings nothing will not tell you either.
MCP
Anthropic, open standardProtocol
An open protocol connecting any agent to external tools, data and services.
Problem, mechanism & fit
The actual pain
Without a standard, every agent-to-service integration is a bespoke adapter, and every agent needs its own.
How it works
A server exposes tools and resources over a common protocol; any compatible agent consumes them. Write the integration once and every agent uses it, including the one you pick up next year.
When it fits
It is the reason your memory and your code index can survive a change of tool. Resist greed: every connected server occupies the window before the work starts.
05
Method
In what order does the work happen, and who does each part?
Splitting work into phases with something handed over between them, instead of asking for one large task in one go and seeing what comes out.
OpenSpec
Fission AIWorkflow
File-backed spec-driven development: what is already agreed, kept apart from what is being proposed.
Problem, mechanism & fit
The actual pain
You agree in the chat on what to build, the agent builds something else, and there is nowhere to point at what was agreed. The conversation the decision lived in is closed.
How it works
Keeps the current specifications in the repository, separate from proposed changes. Each change opens a folder with the proposal, the delta specs, the design and the tasks; once applied and verified, the deltas merge into the current specs and the change is archived. All of it is markdown in your repo: the commands are regenerated for whichever assistant you use, the files are not.
When it fits
When the gap between what you asked for and what came out is your recurring problem, and you want the argument to happen before the code. On a two-line change it is pure cost.
Gentle AI
Gentleman ProgrammingWorkflow
Reproducible configuration installer, spec-driven phased development, and review with a budget.
Problem, mechanism & fit
The actual pain
A hand-configured environment does not reproduce on another machine. And an AI review with no limit does not converge on its own: ask again and another observation arrives.
How it works
Installs and syncs agents, procedures and profiles by preset and scope. Adds a phased cycle — explore, propose, specify, design, tasks, apply, verify, archive — and a bounded review that picks the kind of analysis from the risk of the change, with a correction budget fixed in advance.
When it fits
When the problem is no longer making the agent work, but making it work identically on every machine and making review terminate.
gstack
Garry TanWorkflow
Twenty-plus procedures assigning product roles — product, design, QA, release — across a sprint cycle.
Problem, mechanism & fit
The actual pain
One agent doing everything does everything halfway. Planning, designing, reviewing and shipping apply different standards.
How it works
Installs commands chaining a think, plan, build, review, test, ship and reflect cycle, with deliverables handed from one phase to the next. Works across several different agents.
When it fits
When you work alone and need the standards a team would supply. It is a strong opinion about how software gets built: if it does not match yours, you will fight the tool.
Subagents
Ecosystem patternPattern
Secondary agents with their own context, for work that should not inflate the main thread.
Problem, mechanism & fit
The actual pain
Reading twenty files to answer one question leaves twenty files in the window, and everything after that thinks worse.
How it works
The main agent delegates a scoped task to a secondary one, which works in its own context and returns only the conclusion. The cost of the dirty work is not paid in your window.
When it fits
When a task produces a lot of noise and one small conclusion. The opposite mistake costs just as much: delegating something you already knew forces the other one to rediscover it cold.
06
Control
How do you know what it built works?
Having something that assumes the agent got it wrong and proves otherwise: tests that fail first, review not done by the author, and checks that cannot be skipped.
Skills for Real Engineers
Matt PocockPackage
A procedure collection built around the specific failures of AI-assisted development.
Problem, mechanism & fit
The actual pain
Generic procedures do not help much. These target named failures: it understood something other than what you asked, buggy code, architecture that quietly degrades.
How it works
Procedures that interrogate you before coding to align on what gets built, produce a file establishing the domain vocabulary, enforce test-first loops, and apply a structured method for diagnosing bugs.
When it fits
Once the environment works and the problem has shifted from capability to discipline. The underlying idea — agree the domain vocabulary before writing code — is worth stealing even if you install nothing.
Hooks
Ecosystem patternPattern
Deterministic commands that run at defined moments, without passing through the model.
Problem, mechanism & fit
The actual pain
Telling the model to “always run the linter before committing” is a suggestion. Sometimes it complies. On something non-negotiable, sometimes is the same as never.
How it works
The environment runs a command at a point in the cycle — before an action, at session start, on stop — and uses its output. Because it never passes through the model, it is not open to interpretation or forgetting.
When it fits
For anything that has to happen every time. If you would describe it as “no exceptions”, it belongs in a hook, not a prompt.