AI Agent Tools

multica50.2k★

Multica manages a fleet of AI coding agents like they're people you hired. Instead of babysitting one agent in your terminal, you assign issues to agents, group them into squads under a leader, watch their progress live, and schedule recurring jobs. It's runtime-agnostic, so it drives Claude Code, Codex, Copilot CLI, Cursor Agent, Gemini, and others rather than locking you to one. You can self-host it, and for internal use across your own team that's free. The stack is a Go backend, a Next.js frontend, and Postgres with pgvector, so standing it up yourself is real ops work, not a one-click install. Recent versions added the headline pieces: squads for routing work to a stable group of agents, a catalog of agent templates you can spin up in one click, and autopilots for scheduled recurring tasks. It's iterating fast, with near-daily releases. For a solo developer or a small team that wants to run several coding agents in parallel with real visibility into what each one is doing, this is a genuinely useful control layer, and the self-hosted version is free for your own organization. The thing to read carefully is the license. It's a modified Apache 2.0: you can use it internally all you want, but you can't offer Multica as a hosted service to other people or strip its logo without a commercial license, and there's a managed cloud at multica.ai for teams that don't want to self-host. The catch is that this is source-available, not classic open source, and it's young. If you're a developer running it for your own team, none of the restrictions touch you and it's free. If you're thinking about building a product on top of it or reselling it, that's exactly what the commercial clause is there to stop. Know which side of that line you're on before you commit.

oh-my-claudecode39.3k★

oh-my-claudecode turns Claude Code into a multi-agent team coordinator. You describe a job in plain language and it dispatches specialized agents that plan, build, review, and test in parallel, passing work between themselves without you driving each step. MIT-licensed, installs through the Claude Code marketplace or as an npm CLI. No server to run. It lives inside your Claude Code session and extends the built-in agent tooling. The canonical mode is now explicit team orchestration via /team syntax, which replaced the older swarm keyword. It also routes compatible work across other CLIs you have installed (Codex, Gemini, Grok, Cursor) to save Anthropic tokens, and extracts reusable skills as it goes. Solo developers get a structured way to run long, multi-step tasks without micromanaging each agent. Small teams get a shared pattern for agent pipelines instead of everyone rolling their own. There is no paid tier and no cloud version. You bring your own Claude Max, Pro, or API key. The catch: it moves extremely fast, and that speed shows. Releases land constantly and keywords get deprecated mid-stream (swarm and autoresearch already went), so a setup that worked last month may need adjusting. Multi-agent pipelines also burn tokens faster than a single prompt, and if you don't trust the autopilot, you will review more code than you write.

qm15.1k★

qm is Y Combinator's own open source answer to running a fleet of AI agents across a team. It's a "multiplayer agent harness for work": every person gets an isolated workspace with personal and shared scopes, you drive it from Slack or a web UI, and it can run background and scheduled agent jobs. This is YC Labs code, not a fan project trading on the name, the release is announced on ycombinator.com and served from qm.ycombinator.com. The interesting part is the multiplayer framing. Instead of each developer babysitting one agent in a terminal, qm treats agents as shared, always-on coworkers with their own scopes and cron schedules. For a team already leaning on coding agents, it's a free way to run them coordinated instead of siloed. Solo use works too, but the design clearly targets groups. The catch is that it's brand new. The commit history is short and the stars arrived fast, which means the code is early and production-readiness is unproven. The pedigree is real and the idea is sharp, but pilot it on non-critical work before you wire it into how your team actually ships.

omnigent10.0k★

Omnigent puts one layer over all your AI coding agents so switching between them stops being a rewrite. Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, and custom agents defined in YAML run through a single harness with shared policy controls, and you can mix several in one session or swap mid-conversation. Agent choice becomes a config line. Apache 2.0. Access has broadened past the terminal: browser, phone, and desktop all reach the same session, which is the feature that matters when an agent has been grinding for twenty minutes and you walked away from your desk. Install is a single curl command, or Python 3.12+ manually. Run the server locally, or deploy it with Docker Compose to Render, Railway, Fly.io, Modal, or Cloudflare. The sandbox story is the other reason to look. Agent execution can be pushed into Modal, Daytona, E2B, or Kubernetes instead of running against your filesystem, with credentials hidden from the agent. Solo developers running two or three agents get the policy controls alone worth the setup. Small and medium teams get the most from shared sessions and remote access. Large teams should read the policy model closely first. The catch is that a meta-harness inherits every underlying harness's quirks and adds its own. Each agent still has features the abstraction does not fully expose, and when something breaks you have two layers to debug. The project moves fast with a large open issue queue, so pin your version.

cumora3.7k★

Cumora is team chat where the AI agents are on the roster, not in a sidebar. Same DMs, same group rooms, same Kanban board and calendar as the humans. Each agent carries a persona, a private workspace of files and notes, and memory of past conversations, and on a cadence you set they wake up, read the room, and decide whether to DM someone or start a thread. Agents DM each other too, and you can watch those conversations without joining them. MIT licensed, from the developer behind avante.nvim, so the polish is not accidental. Self-hosting is lighter than the architecture diagram suggests. The real minimum is Postgres, Redis, and one npm command, with an OpenAI key as the only hard-required variable; everything else has a local default or quietly disables itself. Cloudflare Workers for email, R2 storage, push notifications, and per-agent Kubernetes pods are optional feature groups you turn on when you want them, not the price of admission. Lighter still is BYOA: pair your own Mac or VPS with the cumora agent CLI and the agent's brain becomes your local Claude Code or Codex install on your existing subscription. The server never sees your provider keys. Solo builders should run BYOA and skip the server entirely. Small teams get the most out of it, since the premise is agents coordinating in rooms rather than one person prompting one box. Larger teams can self-host on Postgres and Redis without much drama, but there is no hosted price to plan around yet, so budget for running it yourself. The catch is maturity. This is a first release, the cloud is invite-only and free during preview, and nothing says what happens when the preview ends. The agent-initiative feature is also the thing most likely to annoy you: agents that wake on a timer and start their own conversations are great until four of them fill a room overnight. Start with two and turn the cadence down.

sprix-sage-router3.7k★

SAGE decides which agent should do the next piece of work after execution has already started. Agent discovery tells a system who exists; it does not answer whether the agent currently working should continue alone, recruit a collaborator, or hand the whole task off. SAGE scores those three routes in one objective under permission, budget, and deadline constraints. MIT, Python, and it sits above the A2A protocol rather than replacing it. The design choices are more interesting than the pitch. Trust is learned per agent and per requirement rather than as one reputation score, so strength at coding does not imply strength at research. Teams get credit for covering the requirements still outstanding, not for collecting high-ranked but redundant agents. Every decision emits assignments, topology, cost, latency, risk, and a readable rationale. Free with nothing above it. The costs are the model calls your agents were already making, plus routing overhead from scoring candidate teams before each decision. The catch is that this is research output, not production infrastructure. It was published in August 2026 by a small lab, the benchmarks are its own, and the learned outcome model is described as a stand-in for a real reward model later. Read ALGORITHM.md before wiring it into anything that matters.

sol-advisor2.6k★

Sol-advisor packages an opinion about how AI coding work should be split: a read-only advisor model that reviews, an implementation lane that writes code, and an optional third lane for task-based work. It's a plugin for OpenAI's Codex ecosystem, installs with one command, and it's MIT licensed and free. There's more engineering here than the prompt pack it might sound like: a dependency-free MCP server with real test coverage, fail-closed defaults (no fallback models, no arbitrary write paths), and a consent flow that previews every file before it writes anything. Adapters exist for Cursor, VS Code, and Copilot, but this is Codex-first, and every other client is a second-class path. Use it if you're on Codex and want a mandatory fresh-context review before code gets accepted, without designing that workflow yourself. Skip it if you're not: the honest alternative is configuring Codex's own custom agents by hand, and Claude Code users already have subagents and skills natively. The catch: the review lane means paying a large reasoning model to examine work you already paid another model to do, and the whole thing is a young solo project welded to specific model IDs and a plugin spec OpenAI could change any week.

MiroFish-Offline2.5k★

MiroFish-Offline runs multi-agent AI simulations and predictions completely offline using a Neo4j knowledge graph and Ollama for local LLM inference. It's a simulation engine where multiple AI agents interact, predict outcomes, and build up a knowledge base over time. This is niche but powerful for scenarios like market simulation, scenario planning, or research where you can't send data to external APIs. Everything runs locally: the database, the models, the agents. The catch: AGPL-3.0 license (if you modify it and offer it as a service, you must open source your changes). Requires Neo4j and Ollama running locally. That's a real setup commitment. And 'offline multi-agent simulation' is a small but growing niche.

claude-peers-mcp2.2k★

Claude-peers-mcp is an MCP server that lets multiple Claude Code instances message each other in real time. If you run parallel Claude sessions (one on the frontend, one on the backend, one writing tests), this creates a direct communication channel between them so they can coordinate without you copy-pasting context between terminals. The way it works: you spin up the MCP server, connect each Claude Code instance to it, and they can send and receive messages from each other ad-hoc, like a group chat between your AI assistants. One session can ask another about an API contract it just wrote, or flag a dependency change that affects the other's work. It removes you as the bottleneck in multi-agent workflows. The catch: very new and tightly coupled to Claude Code's MCP ecosystem. It does not work with other AI agents or coding assistants. Coordinating AI sessions is still experimental territory, so expect rough edges and limited documentation. If you only run one Claude session at a time, you do not need this.

Lody1.1k★

Lody is a shared workspace for the coding agents your team already pays for. Connect a laptop, server or cloud VM with one command, then hand work to it from desktop, mobile, web or a script. It speaks the Agent Client Protocol, so Claude Code, Codex, Cursor, Cline and Goose all plug in. Apache 2.0. The free tier is real, not a demo: two workspaces, three team members, 200 sessions per workspace and 30 turns per session, with the mobile apps included. Sessions get their own Git worktrees so parallel agents do not collide, and the pull request panel syncs diff comments back into GitHub Review. Plus runs $10 per seat monthly, or $8 billed yearly, discounted to $60 per seat per year through September 30. That lifts every cap. Solo: free covers you. Small teams: the 30-turn ceiling pushes you over, not the seat count. Large teams: Enterprise, because SSO lives there alone. The catch is that the open source half is the client. The workspace syncing your sessions runs on Lody's servers, the docs carry no self-host path, and end-to-end encryption is still listed as coming soon. The project is moving toward local-first. It is not there yet.

AgentSpace998★

AgentSpace is a shared workspace where humans and AI agents work as one team, instead of you driving a single agent in isolation. The idea: give agents defined roles, permissions, and an audit trail, then let them coordinate in channels the way a human team would. Most agent frameworks assume one person and one agent; AgentSpace is built for a group running several agents with governance around them. Apache 2.0 licensed. The interesting piece is AgentRouter, which routes tasks across different agent runtimes, Claude Code, Codex, OpenCode, and others, through one normalized interface, so you are not locked to a single backend. There is a digital employee board that makes agents visible and shareable across an org, a permission and approval system that puts a human checkpoint in front of sensitive actions, and full logging of everything an agent does. You can self-host it or use the hosted platform. This is early, and it is aimed at founder teams and small orgs that want to put agents to work without losing track of what they are doing. The audit trail and approval gates are the real draw; running multiple agents with no oversight gets dangerous fast. Self-host it for full control of the infrastructure, or take the hosted option if you would rather not run it yourself. The catch is maturity. This is a young project moving fast, and multi-agent coordination is still proving itself across the whole industry, not just here. The governance framing is genuinely useful, but expect rough edges, and verify the hosted tier's pricing before you depend on it, since that is not clearly published yet.