Five Open Source Tools That Extend Coding Agents, and the Layer They Leave Out

TL;DR: Five open source projects crossed 40,000 stars this year by removing a different limit from Claude Code, Cursor, and Codex: specialist roles, internet access, parallel execution, video production, and cheap structural recall. Each one expands what an agent can do inside a session. None of them adds a shared record of what the agents did. That layer is a separate job, and it is the one your team feels first.

Coding agents converged. Claude Code, Codex, Cursor, and OpenCode all read a repository, edit files, run commands, and call MCP servers. Once the core loop stopped being the difference, the interesting work moved one layer out, into the things you attach to the agent.

Here are the five attachments worth knowing, what each one does, and the boundary they share.

The five

Star counts are from the GitHub API on September 1, 2026.

agency-agents is a library of role definitions. More than 300 markdown files across roughly 20 categories, each describing an identity, a working process, deliverables, and a definition of done. An install script writes them into Claude Code, Cursor, Codex, Gemini CLI, OpenCode, and a dozen other tools. A persona changes how an agent frames a task. It does not give the agent information it lacks. Full guide: role definitions and what they cannot hold.

Agent-Reach is one CLI that connects an agent to X, Reddit, YouTube, GitHub, RSS, and about a dozen more platforms, using free access paths rather than paid platform APIs. Every platform routes through a primary backend with fallbacks, so when an access path breaks the project switches the default and your setup keeps working. The cookie-based platforms read through a logged-in browser session, which is worth reviewing against the terms of any account you connect. Full guide: web access and where findings should land.

Orca is a desktop application for running several coding agents at once, each in its own git worktree. It drives any CLI agent through the subscriptions you already have, and it adds terminal splits, diff annotation, remote worktrees over SSH, and a mobile companion. The parallel worktree model is the right primitive for this problem, and Orca implements it well. Full guide: parallel worktrees and when a team needs more.

OpenMontage turns a coding assistant into a video production system: eleven pipelines that carry a request through research, script, scene plan, asset generation, edit, and render, with human approval gates between stages. Note the license before you build on it. OpenMontage is AGPL-3.0 while the other four are MIT, and the network clause is a decision for your legal team rather than a footnote. Full guide: agentic video and the approval problem.

codebase-memory-mcp indexes a repository into a persistent knowledge graph of functions, classes, call chains, and routes, then answers structural questions from the graph instead of grepping. The project measures five structural queries at roughly 3,400 tokens through the graph against roughly 412,000 through file-by-file exploration. It is a single native binary, it runs locally, and it is the entry on this list with the best return for the least workflow change. Full guide: cheap recall and the memory it does not hold.

What all five share

Each one expands execution. More capable prompting, more sources, more concurrency, more output formats, more recall inside a session.

None of them changes what happens after the session ends.

That is not a criticism. It is a separation of concerns, and these projects are correct to stay on their side of it. The agent tool performs execution. Something else has to hold the assignment, the context, the progress, and the review. When nothing holds those, the work exists only in one person’s terminal.

The symptom is familiar. An agent produces a good result on Thursday. On Monday a teammate asks why the retry logic changed, and the answer is in a scrollback on a laptop, if that worktree is still open. The prompt was the only record, and a prompt is not a record.

The layer they assume

A Task is the main unit of work in Sharkly. It carries the request, the context, the execution, the blockers, and the result in one shared place instead of splitting them across private prompts and terminal sessions.

The pieces have one job each. The Agent defines how work should be handled. The Computer supplies the host and local resources. The Runtime performs the actual agent session, using the tools your team already installed. The Task remains the shared record.

That division is worth reading against the five projects above, because it explains what composes and what does not.

Sharkly is not a replacement for Claude Code, Codex, or the tools on this list. It adds the shared task, Computer, context, control, and review layer around them. Model usage continues through the subscriptions or API keys configured in those tools.

So a persona from agency-agents becomes an Agent: a saved configuration with instructions, runtime, skills, repositories, and environment, reused instead of retyped. A Crew is a reusable group of People and Agents coordinated by one leader Agent, which is what a division of specialists needs in order to behave like a team. Repository work runs in an isolated worktree per task, the same isolation Orca applies per pane, applied instead to the unit a team can see. Execution, blockers, results, and follow-up discussion return to the task timeline, so the answer to Monday’s question is in the task rather than in someone’s memory.

The control that matters most is the quietest one: a Task in Backlog does not start a run. Work gets prepared, scoped, and approved before anything executes.

Agents research, execute, test, and report. People set direction, grant authority, and accept the result. Automation stops where team judgment is required.

When you need this, and when you do not

For one person running one agent, a good terminal and a good editor are enough. Install codebase-memory-mcp, keep working, and skip everything else on this page. Adding a task layer to a workflow with one participant is overhead with no reader.

Use a shared work system when a second person needs to know what the agents did: when review has to happen before release, when more than one agent runs at a time against the same repository, or when someone will ask in three months what changed and why.

The threshold is not team size. It is whether the record has to outlive the session.

FAQ

Do these tools conflict with a work management layer? No. They sit on different sides of the same boundary. The tools on this list improve execution inside a session. A work system holds assignment, context, and review around it. Sharkly runs the runtimes your team already installed rather than replacing them.

Which one should a team install first? codebase-memory-mcp, in most cases. It requires no workflow change, it runs locally, and it reduces the tokens an agent spends answering structural questions it would otherwise grep for. The others each ask you to change how you work.

Does running several agents in parallel require Orca? No. Orca is a strong desktop implementation of the parallel worktree model and worth trying if you work alone. If the parallel work needs to be assigned, tracked, and reviewed by more than one person, the isolation belongs on the task rather than on the terminal pane. Both approaches use the same underlying git mechanism.

What does bring your own subscription mean here? Model usage continues through the subscriptions or API keys configured in your coding tools. Model quota depends on the AI coding tools, plans, and API accounts your team connects.

Wrapping up

The 2026 tooling wave is worth adopting. Roles, reach, parallelism, new output formats, and cheap recall are real improvements, and four of the five are permissively licensed and quick to try.

They also share a boundary. Every one of them makes an agent stronger inside a session, and the value of a session is capped by whether anyone can see it afterward. Sharkly exists for that half: the task is the shared record, execution runs on Computers you connect through the runtimes you already pay for, and results return somewhere a person can review and accept them.

Extend the agent. Then give the work somewhere to live.