AgentPack
selvaonline/agentpack
Defina sua equipe de agentes em YAML, obtenha supervisor, UI e MCP server prontos
Ver no GitHubFramework TypeScript para orquestrar equipes de agentes IA multi-especialistas a partir de um arquivo YAML. Inclui UI ao vivo para debug, servidor MCP auto-gerado e harness de avaliação comportamental — tudo pronto para usar, sem boilerplate.
Instalação
npx convez-ai selvaonline/agentpack1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Equipes de agentes especializados com delegação e retry automático
- Prototipagem rápida de sistemas multi-agente para análise, planejamento e escrita
- Validação comportamental e testes de roteamento/completude de agentes
- Exposição de ferramentas de agentes como servidor MCP para consumo externo
Veredito

Solução madura e opinada que elimina boilerplate em sistemas multi-agente. LangGraph.js + dev UI + MCP auto-gerado formam um pacote coeso, ideal para times que querem orquestração sem escrever UI ou wrappers. Templates prontos (VC, M&A, sourcing) reduzem time-to-demo significativamente.
README
A tradução para o português deste README ainda está na fila.
⚡ agentpack
Define your AI agent team in one YAML file. Get a multi-agent supervisor, a live network UI, an MCP server, and a behavioral eval harness — out of the box. TypeScript.

The built-in dev UI during a live run: the supervisor delegates across specialists, tools glow as they execute, every hop is streamed and counted. You write none of this.
Why
Multi-agent frameworks give you orchestration primitives and a blank screen. Everything that makes an agent team demoable, debuggable, and trustworthy — a UI that shows who's doing what, an MCP server so other agents can call your tools, evals that prove the team behaves — you build yourself, every time.
agentpack inverts that. The orchestration engine (LangGraph.js) is the boring part. The batteries are the product:
| You write | You get for free |
|---|---|
agentpack.yaml — the team | LangGraph supervisor with delegation, retries, conversation memory |
| Prompts — markdown files | Live agent-network dev UI with hop-by-hop animation (SSE) |
| Tools — plain TS objects | Auto-generated MCP server (every tool, schemas derived, zero wrappers) |
| Eval cases — JSON | Behavioral eval harness: routing, completeness, refusal, latency budgets |
Five minutes to a running team
npx @selvaonline/agentpack init my-team
cd my-team
cp .env.example .env # add ONE key: OpenAI, Gemini, or Groq
npx agentpack dev # → http://localhost:3000
You now have a working travel-planning team — a supervisor delegating to a destination scout, a budget planner, and an itinerary writer over deterministic demo tools. Ask it:
Plan a 5-day trip to Japan in spring on a $3000 budget: research the destination, estimate the costs, and write a day-by-day itinerary.
Then prove it behaves:
npx agentpack eval # routing / completeness / refusal — against the live server
PASS routing_budget agents=["budget_planner"] tools={"estimate_costs":1}
PASS completeness_full_plan agents=["destination_scout","budget_planner","itinerary_writer"]
PASS honesty_refusal agents=[] (off-topic request: no delegation, polite decline)
Templates: a full deal team in one command
The starter team is a toy. The deal templates are the product — the same six-role deal lifecycle (scout → risk → market → financial modeler → portfolio manager → deal writer) instantiated for three industries:
npx agentpack templates # list available templates
npx agentpack init my-fund --template deal-vc
npx agentpack init acquisitions --template deal-ma
npx agentpack init sourcing --template deal-procurement
| Template | Team | Tools (deterministic demo data — swap for your APIs) |
|---|---|---|
deal-ma | M&A acquisition team | target screening, weighted risk scoring, sector multiples, real DCF math, portfolio fit |
deal-vc | VC investment team | deal-flow sourcing, founder/market risk, TAM/SAM/SOM + dilution math, fund-thesis fit |
deal-procurement | Procurement sourcing team | vendor search, supplier risk, category intel, TCO modeling, spend concentration |
starter | Trip-planning team | the gentlest possible introduction |

The deal-ma template mid-run: Deal Lead delegating across all six roles. Every template ships with its own eval suite — all three pass 9/9.
Reshape the team in seconds
The "agent categories" are pure configuration. Remove the portfolio manager? Delete its block from agentpack.yaml, restart — 2 seconds. Add an ESG analyst? Add a block, a prompt file, and a tool:
- name: esg_analyst
description: Screens deals for ESG red flags and reporting obligations.
prompt: ./prompts/esg_analyst.md
tools: [esg_screen]
The supervisor, the network UI, the MCP server, and the eval harness all pick up the new topology automatically — no code changes anywhere.
The manifest is the framework
# agentpack.yaml
name: trip-planner
supervisor:
name: trip_advisor
# prompt: ./prompts/supervisor.md # optional — a disciplined default is generated
specialists:
- name: destination_scout
description: Researches destinations, attractions, and seasonal weather.
prompt: ./prompts/destination_scout.md
tools: [search_destinations, get_weather]
- name: budget_planner
description: Estimates trip costs and builds budget breakdowns.
prompt: ./prompts/budget_planner.md
tools: [estimate_costs]
tools: ./tools # directory of plain TS/JS modules — auto-discovered
Tools are dependency-free duck-typed objects — no imports from agentpack, trivially unit-testable, reusable anywhere:
// tools/budget.ts
export const estimateCosts = {
schema: {
name: "estimate_costs",
description: "Estimate total trip cost by region and travel style.",
parameters: {
type: "object" as const,
properties: {
region: { type: "string", description: "Asia | Europe | ..." },
days: { type: "number", description: "Trip length in days" },
},
required: ["region", "days"],
},
},
async execute({ region, days }) {
return { totalPerPerson: /* deterministic math, zero LLM tokens */ };
},
};
Edit the YAML, restart. That's the whole iteration loop.
What agentpack dev serves
| Endpoint | What it does |
|---|---|
GET / | Dev UI — live network graph, hop animation, event feed, markdown answers |
POST /api/run | Run a query ({ query, threadId? } → { runId }); follow-ups on the same threadId keep conversation memory |
GET /events/:runId | SSE stream — a clean 9-event vocabulary (hop, tool_executing, agent_step, answer_chunk, …) |
GET /api/network | {nodes, edges} team topology |
GET /api/tools · POST /api/tools/execute | Inspect and call any tool directly — zero tokens, deterministic, golden-testable |
ALL /mcp | Auto-generated MCP server (Streamable HTTP) — connect Claude, Cursor, or any MCP client to your team's tools |
Connect from Cursor or Claude Desktop:
{ "mcpServers": { "trip-planner": { "url": "http://localhost:3000/mcp" } } }
Evals as a first-class citizen
evals/cases.json declares behavioral expectations; the harness drives the real server through the same SSE contract the UI uses — so a green suite means the full stack works:
{
"name": "completeness_full_plan",
"query": "Plan a 5-day trip to Japan in spring on a $3000 budget...",
"expect_specialists": ["destination_scout", "budget_planner", "itinerary_writer"],
"expect_keywords": ["day"],
"budget_s": 240
}
Checks available per case: expect_specialists / min_specialists (routing), expect_keywords / expect_any_keywords (completeness), expect_no_delegation (refusal/honesty), min_tool_calls (tool usage), budget_s (latency — warn at 1×, fail at 2×).
Embed it programmatically
import { loadManifest, createServer } from "@selvaonline/agentpack";
const pack = await loadManifest("./agentpack.yaml");
const { app, registry } = createServer(pack); // an Express app — mount or extend it
app.listen(3000);
Or skip YAML entirely and build the AgentPack object in code — the manifest is sugar, not a requirement.
Design principles
- One runtime. No sidecar servers, no HTTP bridges between your tools and your agents. Everything runs in-process in Node.
- Plain config. YAML + markdown + JSON Schema. No bespoke config languages.
- Tools are deterministic, LLMs decide. Tools take typed args and return JSON — testable with golden tests, callable for zero tokens via API/MCP. The LLM's only job is orchestration and synthesis.
- Glass box by default. If you can't watch the delegation happen, you can't debug it and you can't demo it.
- Evals or it didn't happen. A team you can't test is a liability. The harness ships in the box, not as homework.
A production example
DealSense — a commercial real estate deal-intelligence platform (multi-agent underwriting, risk scoring, IC memos) — is the flagship application of this architecture, deployed on AWS at reagent.selvaonline.com. agentpack is that platform's core, extracted and generalized.
Project structure
src/
types.ts AgentPack / AgentTool / SpecialistSpec + event vocabulary
manifest.ts agentpack.yaml loader (prompts from files, tools auto-discovered)
registry.ts instance-based tool registry + topology
supervisor.ts generic LangGraph.js supervisor (delegation, memory, events)
server.ts Express factory: run API, SSE, tools API, dev UI, MCP
mcp.ts auto-generated MCP server from the registry
devui.ts zero-build live network UI
evals.ts behavioral eval harness
cli.ts agentpack init / templates / dev / eval
templates/
starter/ trip-planning team — the gentle introduction
deal-ma/ M&A acquisition team (6 roles, 7 tools, evals)
deal-vc/ VC investment team (6 roles, 6 tools, evals)
deal-procurement/ procurement sourcing team (6 roles, 5 tools, evals)
Roadmap
- More vertical templates (equity research, insurance underwriting, claims triage)
-
agentpack eval --judge— LLM-as-judge scoring (faithfulness, completeness) on top of deterministic checks - Remote MCP servers as tool sources (
tools: mcp://...in the manifest) - Embeddable network-panel web component for production UIs
- Multi-pack serving (one server, many teams)
- Streaming token-level answers
About
Built by Selvakumar Murugesan. Declarative agent teams for the TypeScript ecosystem, with the batteries (UI, MCP, evals) included.
Open to opportunities in AI engineering / agentic systems. Issues and PRs welcome — first-time contributors get same-day responses.
MIT © Selvakumar Murugesan