agentica-infrastructure
Comprehensive API documentation for building coordinated multi-agent systems.
Install
mkdir -p .claude/skills/agentica-infrastructure && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/2321" && unzip -o skill.zip -d .claude/skills/agentica-infrastructure && rm skill.zipInstalls to .claude/skills/agentica-infrastructure
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Reference guide for Agentica multi-agent infrastructure APIsKey capabilities
- →Define multi-agent coordination patterns
- →Implement swarm and jury consensus logic
- →Access coordination database schemas
- →Track agent state and memory
- →Manage handoff atoms
How it works
The infrastructure provides standardized classes and primitives for building multi-agent systems, using a SQLite-backed database to track state and agent interactions.
Inputs & outputs
When to use agentica-infrastructure
- →Implementing multi-agent coordination patterns
- →Accessing coordination database schemas
- →Building custom agent patterns
- →Debugging agent tracking and memory
About this skill
Agentica Infrastructure Reference
Complete API specification for Agentica multi-agent coordination infrastructure.
When to Use
- Building multi-agent workflows with Agentica patterns
- Need exact constructor signatures for pattern classes
- Want to understand coordination database schema
- Implementing custom patterns using primitives
- Debugging agent tracking or orphan detection
Quick Reference
11 Pattern Classes
| Pattern | Purpose | Key Method |
|---|---|---|
Swarm | Parallel perspectives | .execute(query) |
Pipeline | Sequential stages | .run(initial_state) |
Hierarchical | Coordinator + specialists | .execute(task) |
Jury | Voting consensus | .decide(return_type, question) |
GeneratorCritic | Iterative refinement | .run(task) |
CircuitBreaker | Failure fallback | .execute(query) |
Adversarial | Debate + judge | .resolve(question) |
ChainOfResponsibility | Route to handler | .process(query) |
MapReduce | Fan out + reduce | .execute(query, chunks) |
Blackboard | Shared state | .solve(query) |
EventDriven | Event bus | .publish(event) |
Core Infrastructure
| Component | File | Purpose |
|---|---|---|
CoordinationDB | coordination.py | SQLite tracking |
tracked_spawn | tracked_agent.py | Agent with tracking |
HandoffAtom | handoff_atom.py | Universal handoff format |
BlackboardCache | blackboard.py | Hot tier communication |
MemoryService | memory_service.py | Core + Archival memory |
create_claude_scope | claude_scope.py | Scope with file ops |
Primitives
| Primitive | Purpose |
|---|---|
Consensus | Voting (MAJORITY, UNANIMOUS, THRESHOLD) |
Aggregator | Combine results (MERGE, CONCAT, BEST) |
HandoffState | Structured agent handoff |
build_premise | Structured premise builder |
gather_fail_fast | TaskGroup-based parallel execution |
Full API Spec
See: API_SPEC.md in this skill directory
Usage Example
from scripts.agentica_patterns.patterns import Swarm, Jury
from scripts.agentica_patterns.primitives import ConsensusMode
from scripts.agentica_patterns.coordination import CoordinationDB
from scripts.agentica_patterns.tracked_agent import tracked_spawn
# Create tracking database
db = CoordinationDB(session_id="my-session")
# Swarm with tracking
swarm = Swarm(
perspectives=["Security expert", "Performance expert"],
db=db
)
result = await swarm.execute("Review this code")
# Jury with consensus
jury = Jury(
num_jurors=3,
consensus_mode=ConsensusMode.MAJORITY,
premise="You evaluate code quality",
db=db
)
verdict = await jury.decide(bool, "Is this code production ready?")
Location
API spec: .claude/skills/agentica-infrastructure/API_SPEC.md
Source: scripts/agentica_patterns/
When not to use it
- →Simple single-agent scripts
- →Non-Agentica infrastructure environments
Prerequisites
Limitations
- →Requires adherence to Agentica pattern classes
- →Limited to supported coordination primitives
How it compares
It provides a structured framework for complex agent orchestration instead of building custom, ad-hoc coordination logic.
Compared to similar skills
agentica-infrastructure side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| agentica-infrastructure (this skill) | 2 | 7mo | No flags | Intermediate |
| mcp-builder | 136 | 3mo | Review | Advanced |
| ai-agents-architect | 5 | 6mo | No flags | Advanced |
| llm-app-patterns | 3 | 6mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by parcadei
View all by parcadei →You might also like
mcp-builder
anthropics
Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).
ai-agents-architect
davila7
Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling.
llm-app-patterns
davila7
Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability.
devtu-create-tool
mims-harvard
Create new scientific tools for ToolUniverse framework with proper structure, validation, and testing. Use when users need to add tools to ToolUniverse, implement new API integrations, create tool wrappers for scientific databases/services, expand ToolUniverse capabilities, or follow ToolUniverse contribution guidelines. Supports creating tool classes, JSON configurations, validation, error handling, and test examples.
mcp-builder
keepsty
MCP 服务器构建方法论 — 系统化构建生产级 MCP 工具，让 AI 助手连接外部能力
llm-council
am-will
Orchestrate a configurable, multi-member CLI planning council (Codex, Claude Code, Gemini, OpenCode, or custom) to produce independent implementation plans, anonymize and randomize them, then judge and merge into one final plan. Use when you need a robust, bias-resistant planning workflow, structured JSON outputs, retries, and failure handling across multiple CLI agents.