Skip to main content
skill CX Codex

agentica-infrastructure — Claude Code skill: Agentica multi-agent API

A reference guide to the Agentica multi-agent infrastructure API: 11 pattern classes, consensus primitives and the tracking database schema. Useful when you need exact constructor signatures.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add parcadei/Continuous-Claude-v3 --skill agentica-infrastructure -a claude-code
Open on GitHub

What agentica-infrastructure does

The skill ships the Agentica API spec: 11 pattern classes — Swarm, Pipeline, Hierarchical, Jury, GeneratorCritic, CircuitBreaker, Adversarial, ChainOfResponsibility, MapReduce, Blackboard, EventDriven. Each row lists its key method, from .execute(query) on Swarm to .decide(return_type, question) on Jury and .run(initial_state) on Pipeline. A second table covers primitives: Consensus with MAJORITY, UNANIMOUS and THRESHOLD modes, Aggregator with MERGE, CONCAT and BEST, plus HandoffState, build_premise and gather_fail_fast.

Core infrastructure is documented too: CoordinationDB in coordination.py for SQLite tracking, tracked_spawn in tracked_agent.py, HandoffAtom, BlackboardCache, MemoryService, create_claude_scope. The full spec lives in API_SPEC.md inside the skill directory, and the source sits in scripts/agentica_patterns/. The code sample ties it together: build a CoordinationDB(session_id="my-session"), pass it into Swarm or Jury, await the result.

The skill is marked user-invocable: false and allows only the Read tool, so it is documentation rather than an executor. You cannot fire it as a slash command; ask the agent to read the spec file instead. One catch: the examples import from scripts/agentica_patterns/, so in a project without that directory the sample code will not run.

What it helps with

  • pick a coordination pattern for the job: parallel perspectives, voting or sequential stages
  • copy exact constructor signatures instead of guessing from class names
  • understand the SQLite schema behind agent tracking
  • build a custom pattern from consensus and aggregation primitives
  • trace why an agent went missing or was never tracked

Example prompts for the agent

  • Read .claude/skills/agentica-infrastructure/API_SPEC.md and show me the constructor signatures for Swarm and Jury
  • Build a multi-agent workflow on Swarm with CoordinationDB — I need the tracking example
  • Open the Agentica spec and explain how ConsensusMode.MAJORITY differs from THRESHOLD

How to install agentica-infrastructure

1Skills CLI (Vercel)

npx skills add parcadei/Continuous-Claude-v3 --skill agentica-infrastructure -a claude-code

2Manually: put the files in place

~/.claude/skills/agentica-infrastructure/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/agentica-infrastructure/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about agentica-infrastructure

How do I install agentica-infrastructure in Claude?

Run npx skills add parcadei/Continuous-Claude-v3 --skill agentica-infrastructure -a claude-code. The skill lands at ~/.claude/skills/agentica-infrastructure/SKILL.md.

What does agentica-infrastructure do?

It is a reference guide to the Agentica infrastructure API: tables of pattern classes, primitives and coordination components, plus a code sample. It executes nothing on its own — it hands the spec to your agent.

Why can't I invoke the skill as a slash command?

Its frontmatter sets user-invocable: false and allows only the Read tool. Ask the agent to read the spec file in your prompt instead of typing a command.

Source text

SKILL.md · MIT
---
name: agentica-infrastructure
description: Reference guide for Agentica multi-agent infrastructure APIs
allowed-tools: [Read]
user-invocable: false
---

# 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

```python
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/`

© parcadei · MIT · parcadei/Continuous-Claude-v3

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set77

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor