TL;DR: Five open source AI agent tools are climbing GitHub right now, and each one removes a different limit from Claude Code, Cursor, and Codex: agency-agents gives your agent a roster of specialists, Agent-Reach gives it internet access, Orca runs several agents in parallel worktrees, OpenMontage turns it into a video studio, and codebase-memory-mcp cuts the tokens it burns re-reading your repo. None of them fix the two things that break agent work at scale: the API surface the agent guesses at, and the missing record of what the agents actually did.
Star counts below are from the GitHub API on September 1, 2026. They move fast.
Your coding agent is capable and badly equipped. It writes a service in ten minutes, then spends an hour groping around your repo because it cannot remember what it read yesterday, cannot look anything up on the open web, and cannot run two jobs at once without stepping on itself. The open source community spent 2026 attacking exactly those limits, and a handful of repos crossed 40,000 stars doing it.
This is a tour of the five that matter, what each one really does once you install it, and where each one stops. Along the way, one honest observation: every tool here makes your agent do more, and not one of them makes the results verifiable. If your agent is calling APIs, you still need a deterministic layer that says whether the response was right, which is where Apidog sits in the stack. More on that after the tour.
Why the agent tooling layer exploded this year
The base agents converged. Claude Code, Codex, Cursor, and OpenCode all read a repo, edit files, run commands, and call MCP servers. Once the core loop stopped being the differentiator, the interesting work moved one layer out, into the things you bolt onto the agent.
That layer is cheap to build and cheap to distribute. An agent persona is a markdown file. A tool is a CLI wrapper. A memory system is an MCP server. You do not need model access or a GPU budget to ship any of it, which is why the leaderboard now looks like a list of accessories rather than a list of models.
It is also why quality varies wildly. A repo with 50,000 stars might be a genuinely fast C binary or it might be 300 prompt templates in a folder. Both are on this list. The difference matters, so each entry below says what you are actually installing.
1. agency-agents: 300+ specialist agents in one install command
149,312 stars. MIT licensed. Shell. Started October 2025.
agency-agents is the largest curated collection of agent personas on GitHub. Counting the markdown files in the repo tree, it ships more than 300 agent definitions across roughly 20 category folders: 59 in engineering, 58 in a catch-all specialized bucket, 36 in marketing, then game development, integrations, strategy, GIS, security, design, sales, testing, finance, healthcare, and more.
Each agent is a markdown file with an identity, a working process, deliverables, and success criteria. Not a one-line system prompt. The install script converts them for whichever tool you use:
# clone, then install every agent into Claude Code
./scripts/install.sh --tool claude-code
# or pick your tool and only the divisions you want
./scripts/install.sh --tool cursor --division engineering,security
./scripts/install.sh --tool codex
./scripts/install.sh --tool opencode
Supported targets include Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Copilot, Windsurf, Aider, Kimi Code, and several others. There is also a native desktop app at agencyagents.app for macOS, Linux, and Windows that browses the roster and installs with a click, plus a Homebrew cask.
What it fixes: the blank-slate problem. A generic agent asked to review your authentication flow gives you generic advice. The same agent loaded with a security reviewer persona has a checklist, a threat model, and an output format.
The catch: these are prompts, not capabilities. A persona changes how the model frames a task; it does not give the model information it lacks. The repo is also honest about a real limit worth knowing before you install everything at once: OpenCode’s runtime registers only about 119 agents and silently drops the rest, so install by division rather than in bulk on that tool. Treat the roster as a starting library you edit, not a finished team.
Full guide: agency-agents: 300+ AI specialists for Claude Code and Cursor
2. Agent-Reach: internet access without paying for platform APIs
77,134 stars. MIT licensed. Python. Started February 2026.
Ask your agent what people are saying about a library on X, and it fails. Ask it to summarize a YouTube tutorial, and it fails. The information density on social platforms is high, and the API pricing on those platforms is hostile.
Agent-Reach is a single CLI that wires your agent into those platforms using free access paths instead of paid APIs. It covers Twitter/X, Reddit, YouTube, GitHub, Facebook, Instagram, Bilibili, XiaoHongShu, podcast transcription, and general web search. Setup effort varies by platform: GitHub works with zero configuration through the gh CLI, web search auto-configures through Exa, X and XiaoHongShu need a browser cookie or an existing Chrome session.
The design decision that makes it durable is the fallback chain. Every platform routes through a primary backend with a list of alternates. When an access path breaks, the project switches the default and you never touch your config. Their own example: Bilibili started returning 412s to yt-dlp in June 2026, so they moved to a different client, and users did nothing.
What it fixes: research. Your agent stops answering from a training cutoff and starts reading what shipped this week.
The catch: free access paths are free because they are unofficial. Cookie-based reading of a logged-in account is a gray area on most of these platforms, and you should read the terms of the accounts you connect before you point this at anything commercial. Also budget for maintenance windows. A fallback chain reduces breakage; it does not eliminate it.
Full guide: Agent-Reach: internet access for your agent without paying for APIs
3. Orca: several agents in parallel, each in its own worktree
58,464 stars. MIT licensed. TypeScript. Started March 2026.
Orca, from Stably, is a desktop app for running a fleet of coding agents at once. It drives Codex, Claude Code, OpenCode, and Pi through your existing subscriptions rather than reselling you tokens, and it runs on macOS, Windows, and Linux.
The core feature is parallel git worktrees. You fan one prompt across several agents, each gets an isolated worktree, and you compare the diffs and merge the one that worked. That is the single most useful pattern for a hard problem where you cannot predict which approach lands, and doing it by hand across five terminal tabs is miserable.
Around that, Orca adds terminal splits with WebGL rendering and scrollback that survives restarts, GitHub and Linear browsing in-app so you can open a worktree straight from an issue, a Design Mode that sends an element’s HTML, CSS, and a cropped screenshot from a real Chromium window into the agent’s prompt, and a mobile companion app on iOS and Android that notifies you when a run finishes so you can send a follow-up from your phone.
What it fixes: the serialization problem. One agent in one terminal is one unit of throughput, and your attention is the bottleneck.
The catch: it is a single-machine, single-operator tool. Everything lives on your laptop, and the record of what happened lives in your scrollback. That is fine solo and awkward the moment a second person needs to know what any of those agents did. Hold that thought.
Full guide: Orca: parallel worktrees for Codex, Claude Code, and OpenCode
4. OpenMontage: your coding agent as a video production studio
55,047 stars. AGPL-3.0. Python. Started March 2026.
OpenMontage is the strangest entry here and the most fun. It turns a coding assistant into an agentic video production system: 12 production pipelines, over 100 tools, and more than 700 skill and production-knowledge files that teach the agent how to direct, script, generate assets, edit, and render.
The part that separates it from every “AI video” wrapper is that it can build real motion footage. Instead of only animating a handful of stills, the agent assembles a corpus from free stock and open archives, retrieves actual clips, cuts them into a timeline, and renders the result. It composes through Remotion and ffmpeg, and plugs into providers like ElevenLabs and Google TTS for voice.
What it fixes: the gap between a written deliverable and a watchable one. Release notes, changelogs, and docs are content your agent already produces. This turns them into video without a separate team.
The catch: read the license before you build a business on it. OpenMontage is AGPL-3.0, not MIT like the rest of this list. If you run a modified version as a network service, the AGPL’s network clause obliges you to offer that source. That is a deliberate choice by the maintainers and a fine one; it is also a legal question for your company, not a detail to skim.
Full guide: OpenMontage: turn your coding agent into a video studio
5. codebase-memory-mcp: stop re-reading the repo on every question
41,536 stars. MIT licensed. Written in C. Started February 2026.
This is the one I would install first, and the least flashy.
Every time your agent needs to answer a structural question, where is this function called, what routes hit this handler, what breaks if I change this signature, it greps and reads its way to an answer. That works and it costs a fortune in tokens. On a long session it is also the reason you hit your usage limit before lunch.
codebase-memory-mcp indexes your repository into a persistent knowledge graph of functions, classes, call chains, HTTP routes, and cross-service links, then answers those questions from the graph. Parsing runs through tree-sitter across more than 160 languages, with semantic type resolution layered on for a dozen of the big ones including Python, TypeScript, Go, Java, Rust, C#, and C++.
The numbers the project publishes are the reason it is on this list. Five structural queries cost about 3,400 tokens through the graph versus about 412,000 tokens through file-by-file exploration, a 99.2% reduction. Indexing the Linux kernel, 28 million lines across 75,000 files, takes three minutes. Structural queries return in under a millisecond. The design and benchmarks are written up in an arXiv preprint that reports 83% answer quality, 10 times fewer tokens, and 2.1 times fewer tool calls across 31 real repositories.
It ships as a single native binary with no language runtime, no hosted service, and no API key, exposes 15 MCP tools, and runs entirely on your machine. There is a 3D graph viewer at localhost:9749 if you want to look at what it built.
What it fixes: the token bill, and the quality drop that comes from an agent filling its context with file contents instead of reasoning.
The catch: the honest one, which the project states in its own README, is that this tool reads your codebase and writes to your agent config files. That is its job, and it is also a reasonable thing to audit before running. The source is open, releases are scanned and reproducibly packaged, and nothing leaves your machine. Verify that for yourself rather than taking a star count as a security review.
Full guide: codebase-memory-mcp: cut your agent token bill by 99%
What these five have in common
Line them up and the pattern is obvious. Every one of them expands what the agent can do:
| Tool | Adds | Stars | License |
|---|---|---|---|
| agency-agents | Role and process framing | 149.3K | MIT |
| Agent-Reach | Reading the live internet | 77.1K | MIT |
| Orca | Parallel execution in worktrees | 58.5K | MIT |
| OpenMontage | Video production output | 55.0K | AGPL-3.0 |
| codebase-memory-mcp | Cheap structural recall | 41.5K | MIT |
Not one of them expands what you can verify. Give an agent 300 personas, live web access, five parallel worktrees, and perfect recall of your repo, and you have an entity that produces five times as much work per hour with exactly the same confidence level as before, which is to say none that a reviewer can act on.
Two specific gaps stay open, and both get worse as you install more of this stuff.
Gap 1: the API surface your agent is still guessing at
Ask any of these tools what the response shape of your internal billing endpoint looks like, and the honest answer is that they infer it. codebase-memory-mcp knows which handler serves a route because it parsed your code. It does not know that the handler returns a 409 with a different error envelope when the idempotency key repeats, unless somebody wrote that down somewhere the agent can read.
So the agent writes a client that looks right and handles the shape it imagined. The tests it writes pass against the mock it also imagined. Everything is green until it hits your actual staging environment. We wrote up how this failure specifically bites when the upstream shape shifts under a working agent in what happens when API changes break AI agents, and why response payloads eat agent context in agent tool response context windows.
The fix is not a smarter agent. It is a specification the agent reads instead of guesses at, plus a mock and a test suite that fail loudly when reality diverges. That is what Apidog is for in this stack:
- The OpenAPI spec is the source of truth. Design the endpoint once, and the agent reads the real schema, the real status codes, and the real error envelopes rather than reconstructing them from call sites. The reasoning behind that pattern is in using your OpenAPI spec as agent tools.
- Mocks come from the spec, not from the agent’s imagination. Smart mock generates responses that match the schema, including the error branches your agent would never think to fake.
- Tests are deterministic. Assertions run in CI and fail on a shape change. The agent’s confidence is not evidence; a red test is.
- Tool schemas stay clean. If you are exposing your API to an agent, how you shape those definitions decides whether the agent calls them correctly. See designing API tool schemas for agents.
None of that competes with the five repos above. It sits underneath them. codebase-memory-mcp tells the agent where the code is; Apidog tells it what the contract is and whether the result matched. If you want the longer argument for why an API tool survives the agent era rather than being replaced by it, that is here. Download Apidog if you want to wire the spec into your agent’s context and stop paying for hallucinated response shapes.
Gap 2: nobody can see what the agents did
The second gap shows up the moment there is more than one of you.
Orca solves parallelism beautifully for a single operator on a single machine. Five worktrees, five agents, one person watching. Now put that person on a plane. What did agent three change and why? The answer is in a terminal scrollback on a laptop in an overhead bin. The prompt was the only record, and prompts are not a record.
That is the gap Sharkly fills. It is a work management system for people and agents, where the task rather than the prompt is the shared record.
The model is close enough to a project tracker that a team already understands it, and different in the places that matter for agent work:
- You assign a task to an Agent the way you assign it to a teammate. An Agent is a saved configuration: instructions, runtime, skills, repositories, environment. A working setup you tuned once gets reused instead of retyped into a fresh terminal every morning.
- A Crew is a leader agent plus other agents and people. Crews run leader-first. The leader reads the task context, decides which members to pull in, and combines their results in one place, instead of every agent starting at once and racing.
- Execution is bring your own. You connect a Computer, which can be your laptop, a server, or a container, and Sharkly uses the Runtime already installed on that machine. Model usage runs through the subscriptions and API keys you already pay for, exactly like Orca’s approach, so nothing here resells you tokens.
- Repository work runs in a separate worktree per task. Same isolation trick that makes parallel agents safe, applied at the task level rather than the terminal level.
- Backlog means backlog. A task sitting there does not start a run. You prepare work before anything executes, which is the checkpoint most agent setups are missing.
- The output lands where a human can review it. Progress, tool calls, and results stream back to the task, and the agent’s output is stored as comments you reply to. Structure comes from spaces, projects, sprints, and tasks, with Jira sync for teams that already live there.
The practical difference: reviewing three finished tasks in an inbox beats watching three terminals. If a teammate asks what the agents shipped this sprint, there is an answer that is not a screen recording. It pairs with everything above rather than replacing it, and it pairs especially well with Orca, which is the single-operator version of the same idea.
A stack that holds together
If you install all five repos on Monday you will have a mess by Wednesday. A saner order, based on what each one actually pays back:
- codebase-memory-mcp first. It reduces cost and improves answer quality immediately, on every project, with no workflow change. Best ratio on this list.
- Agent-Reach second, if you research. Start with the zero-config platforms, GitHub and web search, before you go near cookie-based access.
- agency-agents third, by division. Install engineering and whatever else you actually use. Do not install 300 personas and hope. Edit two or three into something that matches how your team works.
- Orca when you are the bottleneck. The moment you are waiting on agents more than they are waiting on you, parallel worktrees pay for themselves.
- Sharkly when a second person needs visibility. Solo, Orca is enough. On a team, the durable task record is the thing you cannot fake with scrollback.
- Apidog underneath all of it, if agents touch your APIs. The spec, the mock, and the test suite are what turn agent output into something you can merge without reading every line. Related reading: production AI agent reliability and tracing agent tool calls.
OpenMontage sits outside that ladder. Install it when you have a video to make, not as part of a default setup.
FAQ
Are these star counts real? They are what the GitHub API returned on September 1, 2026. All five repos are public, actively pushed within the last two weeks, and carry real code rather than placeholder READMEs. Star counts on agent tooling inflate fast through aggregator posts, so treat them as popularity, not quality. The commit history and the issue tracker tell you more.
Do these work with Cursor and Codex, or only Claude Code? All five support multiple agents. agency-agents ships install targets for a dozen tools. codebase-memory-mcp is an MCP server, so anything that speaks the Model Context Protocol can use it, and the project lists 45 client surfaces. Orca explicitly runs Codex, Claude Code, OpenCode, and Pi side by side. If you are choosing between agent clients, our comparison of API work in Cursor and Copilot covers the tradeoffs, and Codex in OSS mode covers running open models.
Which one saves the most money? codebase-memory-mcp, by a wide margin, and it is not close. The published measurement is 3,400 tokens versus 412,000 for the same five structural queries. If you are hitting usage limits on long sessions, that is where the tokens are going.
Is it safe to install an MCP server that edits my agent config? Treat it like any dependency with filesystem access. Read the source, check the release signing, and prefer tools that run locally over ones that phone home. codebase-memory-mcp documents its release process and processes everything on your machine, which is the right shape. A large star count is not an audit. The same judgment applies to agent permissions generally, which we covered in AI agent guardrails.
Do I still need an API client if my agent writes all the requests? Yes, and more than before, because the volume of API calls that need checking went up rather than down. The agent generates; something deterministic has to verify. That is the whole argument in do you still need an API tool in the age of AI agents.
Wrapping up
The 2026 agent tooling wave is real and worth adopting. Personas give your agent a frame, Agent-Reach gives it eyes, Orca gives it parallelism, OpenMontage gives it a new output format, and codebase-memory-mcp gives it memory that does not cost 412,000 tokens a question.
What none of them give you is proof. More output at the same confidence level is not obviously progress, and the two places that shows up first are the API contract your agent invented and the work record that only exists in someone’s terminal. Sharkly covers the second one by making the task the shared record instead of the prompt. Apidog covers the first by making the spec, the mock, and the test suite the thing your agent reads and answers to.
Install the tools. Then make the output checkable.
