convez.ai
MCP ServerAutomaçãoIntermediário
selvaonline

AgentPack

selvaonline/agentpack

Defina sua equipe de agentes em YAML, obtenha supervisor, UI e MCP server prontos

Ver no GitHub
InicialPluginScore · de 0 a 100

Framework 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/agentpack

1 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

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

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.

License: MIT Node >= 20 Built on LangGraph.js

agentpack dev UI — live agent network during a run

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 writeYou get for free
agentpack.yaml — the teamLangGraph supervisor with delegation, retries, conversation memory
Prompts — markdown filesLive agent-network dev UI with hop-by-hop animation (SSE)
Tools — plain TS objectsAuto-generated MCP server (every tool, schemas derived, zero wrappers)
Eval cases — JSONBehavioral 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
TemplateTeamTools (deterministic demo data — swap for your APIs)
deal-maM&A acquisition teamtarget screening, weighted risk scoring, sector multiples, real DCF math, portfolio fit
deal-vcVC investment teamdeal-flow sourcing, founder/market risk, TAM/SAM/SOM + dilution math, fund-thesis fit
deal-procurementProcurement sourcing teamvendor search, supplier risk, category intel, TCO modeling, spend concentration
starterTrip-planning teamthe gentlest possible introduction

M&A deal team mid-run

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

EndpointWhat it does
GET /Dev UI — live network graph, hop animation, event feed, markdown answers
POST /api/runRun a query ({ query, threadId? } → { runId }); follow-ups on the same threadId keep conversation memory
GET /events/:runIdSSE 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/executeInspect and call any tool directly — zero tokens, deterministic, golden-testable
ALL /mcpAuto-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

  1. One runtime. No sidecar servers, no HTTP bridges between your tools and your agents. Everything runs in-process in Node.
  2. Plain config. YAML + markdown + JSON Schema. No bespoke config languages.
  3. 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.
  4. Glass box by default. If you can't watch the delegation happen, you can't debug it and you can't demo it.
  5. 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

Ver o original no GitHub

Bom para

Relacionados