Before you start: these are separate services and plugins, each with its own dependencies and setup. Ports shown below are the documented defaults from each repository's .env.example or install guide — they are configurable, and nothing here is running until you start it yourself. Each repository is the authoritative install reference.
Plugin Ecosystem
What it does
Declarative extension model for Claude Code. Files placed in a plugin directory become agents, skills, commands, hooks, or MCP integrations.
Set up a new plugin
- Create a plugin directory containing a
plugin.jsonwith name, version, and hook manifest - Add
hooks/hooks.jsonfor lifecycle wiring (SessionStart, PreToolUse, PostToolUse, Stop, etc.) - Add
skills/{name}/SKILL.mdfor domain knowledge,agents/{name}.mdfor personas, orcommands/{name}.mdfor slash commands - Critical: PostToolUse and Stop hooks must be wired in
~/.claude/settings.json, not just pluginhooks.json
Common workflows
- Enable a plugin: add it to
enabledPluginsin~/.claude/settings.json - Install from a marketplace:
/plugin marketplace add <source>, then/plugin install <name> - Debug hooks: tail the log files the plugin writes under its own
state/directory
Multi-Agent Orchestration
What it does
The conductor orchestrates 37 specialized agents — 18 workflow agents and 19 kernel agents — through tiered workflows. Agent dispatches are independently validated by Gemini.
Start a new workflow
/conduct new "Build user authentication feature"The conductor classifies the request using a 5-signal matrix (scope, type, risk, ambiguity, intent sensitivity) into a TRIVIAL / MINOR / STANDARD / MAJOR tier, then executes the tier-appropriate phase sequence.
Check workflow status
/conduct statusShows current phase, step, task queue, verification gates, token budget by model tier, and Gemini validation stats.
Resume an interrupted workflow
/conduct resumeValidate completeness
/conduct validateRuns conductor-completeness-validator with its domain-specific check suites.
Context Management
What it does
Monitors context window utilization and escalates through four warning tiers as the session approaches its auto-compaction boundary, so compaction never takes you by surprise.
The four escalation tiers
Tiers are measured as distance remaining to the compaction threshold — a smaller number means less headroom left, so L4 is the most urgent:
| Tier | Severity | Fires at | Guidance |
|---|---|---|---|
L1 | LOW | 30% remaining | Optimize usage — delegate to subagents, use offset/limit on reads, summarize instead of quoting |
L2 | MEDIUM | 15% remaining | Save session state; avoid chaining steps |
L3 | HIGH | 7% remaining | Save final state; finish only the current operation; start a new session |
L4 | CRITICAL | 3% remaining | Compaction imminent — hard-blocks subagent dispatch and persists a reminder |
Each tier fires once per escalation to avoid flooding the UI. A velocity signal can bump the tier up by one when consumption is accelerating, giving earlier warning.
Customize CLAUDE.md
- Global:
~/.claude/CLAUDE.md— persists across all projects - Project-level:
CLAUDE.mdin the project root — loaded when working in that project
Force compaction
/compactPersistent Vector Memory
What it does
Qdrant-backed vector memory exposing 74 MCP tools, with Ollama embeddings (nomic-embed-text) and 34 scheduled n8n workflows for consolidation, pruning, and lifecycle management.
Store a memory
memory_store({
content: "Preference: always use tabs over spaces in this project",
type: "preference",
tags: ["formatting", "project-x"]
})Recall memories
memory_recall({
query: "tab vs space preference",
project: "project-x",
limit: 5
})Query the knowledge graph (GraphRAG)
graph_query({ query: "MATCH (a:Agent)-[:BUILT]->(f:Feature) RETURN a.name, f.name" })
graph_traverse({ start_id: "agent:builder", max_depth: 3 })
graph_time_travel({ node_id: "feature:auth", as_of: "2026-04-01T00:00:00Z" })Agent Governance
What it does
Identity manifests with 5 trust levels, 3-tier tool classification (exempt / standard / elevated), an append-only audit bus, and runtime policy enforcement via PreToolUse hooks.
Add governance for a new agent
Per-agent capability manifests are written under the plugin's state/ directory at runtime. Point the plugin at a different location with GOVERNANCE_MANIFESTS_DIR, and set GOVERNANCE_PLUGIN_ROOT if the plugin is not at its default path. A manifest looks like:
agent_id: "my-agent"
manifest_id: "gov-my-agent"
trust_level: 3
data_classification: "internal"
permitted_tools: ["Read", "Edit", "Bash"]
human_required: falseReview audit events
/governance-auditCheck pending human gates
/governance-reviewHealth status
/governance-statusMemory Dashboard
What it does
FastAPI web UI with a D3.js knowledge graph visualization, analytics charts, and collection browsing. Listens on port 8092 by default and requires a login.
Run it
uvicorn main:app --host 0.0.0.0 --port 8092Then open http://localhost:8092 and log in.
Key views
- Knowledge graph: force-directed D3 visualization of memory links and entity relationships
- Memories and explorer: browse Qdrant collections with point counts and metadata
- Analytics: memory growth over time, tag distribution, tier breakdown
- Search and decisions: query stored memories and recorded decisions
Markdown-for-Agents
What it does
HTTP proxy that converts any URL's HTML to clean markdown for agent consumption. A Playwright fallback handles JavaScript-rendered pages. Listens on 127.0.0.1:8090 by default.
Fetch a URL as markdown
curl http://localhost:8090/https://example.com/Prepend the target URL to the proxy path.
Code Assurance Platform
What it does
Integrates 27 open-source security tools powering 37 analyzers (22 quality + 15 security) — SAST, DAST, SCA, secrets scanning, mutation testing, supply chain verification and AI-security checks — behind one API that coding agents can call over MCP. The backend API listens on port 4000 by default (BACKEND_PORT).
Service endpoints
- Backend API —
http://localhost:4000 - MCP SSE endpoint —
http://localhost:4000/mcp/sse - n8n workflows —
http://localhost:5678
Start a scan
curl -X POST http://localhost:4000/api/v1/scans \
-H "Content-Type: application/json" \
-d '{"projectId": "{id}", "profile": "standard"}'Scan profiles
Scans run under a named profile that selects how many scanners execute and how deep they go — from a fast pre-commit pass through to a full pre-release audit with mutation testing and attestation. The quick, standard and comprehensive profiles are accepted across every entry point; consult the repository's API schema for the complete set, which is still being consolidated across the backend and SDK.
View findings
curl "http://localhost:4000/api/v1/findings?scanId={id}&status=open"Attestation bundles
Successful scans generate an Ed25519-signed attestation with SLSA provenance, retrievable through the attestations and reports endpoints under /api/v1/.
Agentic Data Plane
What it does
TypeScript service on port 8099 providing DAG-based data lineage with chain verification, dataset quality validation and enforcement, pipeline observability, and PII/PHI classification. Routes are mounted under /api/v1 and require a bearer token; a GraphQL endpoint is served at /graphql.
Trace lineage for an output field
curl http://localhost:8099/api/v1/lineage/trace/{outputFieldId} \
-H "Authorization: Bearer {jwt}"Inspect a pipeline DAG
curl http://localhost:8099/api/v1/lineage/dag/{pipelineId} \
-H "Authorization: Bearer {jwt}"Verify the lineage chain
curl http://localhost:8099/api/v1/lineage/chain/verify \
-H "Authorization: Bearer {jwt}"Validate dataset quality
curl -X POST http://localhost:8099/api/v1/quality/validate \
-H "Authorization: Bearer {jwt}" \
-H "Content-Type: application/json" \
-d '{ "dataset_id": "premium-input", "records": [ ... ] }'Scores and trends for a dataset are available at /api/v1/quality/datasets/{datasetId}/score and /trend, and /api/v1/quality/enforce/{datasetId} applies the configured threshold.
Review data classification
curl http://localhost:8099/api/v1/classification/pipeline/{pipelineId} \
-H "Authorization: Bearer {jwt}"Classifier definitions are at /api/v1/classification/classifiers, with review queue and override endpoints alongside them.
Agent Economics
What it does
Per-interaction cost metering, a four-level budget hierarchy (organization / project / agent class / agent instance), model routing, semantic caching and chargeback reporting. The API listens on port 8097 and every route is mounted under the /economics prefix. Authenticated routes expect an Authorization: Bearer token.
Record a cost event
curl -X POST http://localhost:8097/economics/events \
-H "Authorization: Bearer {token}" \
-H "Content-Type: application/json" \
-d '{
"agent_id": "conductor-builder",
"session_id": "sess-123",
"project_id": "project-x",
"model": "claude-sonnet",
"routed_tier": "sonnet",
"event_type": "llm_call",
"input_tokens": 12500,
"output_tokens": 8200,
"cache_read_tokens": 10000,
"latency_ms": 4200
}'agent_id, session_id, project_id, model and routed_tier are required. The response returns the recorded event_id and computed cost_cents.
Set a project budget
curl -X PUT http://localhost:8097/economics/projects/project-x/budget \
-H "Authorization: Bearer {token}" \
-H "Content-Type: application/json" \
-d '{
"cap_cents": 50000,
"period_type": "monthly",
"threshold_warn_pct": 70,
"threshold_throttle_pct": 85,
"threshold_pause_pct": 95
}'Check spend and budget status
curl http://localhost:8097/economics/projects/project-x/budget \
-H "Authorization: Bearer {token}"Other reporting endpoints
GET /economics/trends— spend over timeGET /economics/chargebackand/chargeback/export— departmental attributionGET /economics/roi/{feature_id}— return on a tracked featureGET /economics/cache/stats— semantic cache hit rate and savingsGET /economics/anomalies— detected cost anomaliesGET /economics/agents/{id}/ledger— per-agent cost ledger
Agent Runtime Security
What it does
A standalone service providing behavioral monitoring, identity lifecycle management, memory integrity verification, a guardian agent, and threat detection for running agents.
Baseline agent behavior
The behavioral monitor builds a baseline from an agent's early invocations. Anomalies — unusual tool call patterns, off-hours activity, permission escalation attempts — are flagged as events.
Review guardian interventions
When the guardian terminates a session it records the intervention, which surfaces through the audit bus alongside the corresponding incident record.
Credential rotation
Ephemeral per-session credentials are rotated by the identity lifecycle manager, which also supports manual rotation.
Self-Healing Workflows
What it does
Automated failure recovery with 7-category classification (transient, model, data, permission, logic, infrastructure, external) driven by a YAML recovery playbook, shipped as the conductor kernel's self-healing skill.
How it triggers
When conductor-recovery-engine is dispatched after an agent failure, it reads references/failure-taxonomy.yaml to classify the error, then applies the matching strategy from references/recovery-playbook.yaml: retry (transient), reroute (permission), degrade (model overload), or escalate.
Resume from checkpoint
conductor-checkpoint saves workflow state at phase boundaries. After recovery, execution resumes from the last good checkpoint rather than restarting.
Event-Driven Automation
What it does
A central event dispatcher with a standardized taxonomy covering session, memory, agent, governance, security, infra, schedule, git, external, recovery and cost events, routed to n8n workflows. Events use dot-notation naming: category.action[.detail].
Browse n8n workflows
open http://localhost:5678Check workflow health
curl -H "X-N8N-API-KEY: $KEY" http://localhost:5678/api/v1/workflowsEmit an event
Agents use conductor-event-router to emit events. The router reads taxonomy.yaml to validate the event and its routing rules to dispatch it, with a dead-letter queue for failures.
Process Knowledge Base
What it does
Structured business rules, decision trees, SOPs and edge-case catalogs for agent decision points, organized by domain with full provenance. A read-only MCP server exposes the process_knowledge Qdrant collection; a companion ingest.py creates and populates it.
Load the example corpus
The repository ships example domain files — development.yaml and security.yaml — alongside a _schema.yaml describing the record format. Run ingest.py to create the collection and load them; use --recreate to rebuild from scratch.
Query domain knowledge
memory_recall({
query: "rule for handling elevated tool requests",
project: "process_knowledge"
})Add a new rule
Edit the relevant domain YAML file, add the rule with its provenance (source, effective date, approver), commit it for version history, and re-run the ingest to publish it.
Outcome Measurement
What it does
A passive observer computing 8 outcome metrics from recorded task events:
- completion_rate — share of tasks reaching completion rather than failure or escalation
- ttr — time from dispatch to terminal state (median and p95)
- first_pass_rate — share of tasks completed with no rework
- rework_frequency — mean rework count per task
- quality_trend — Gemini PASS rate over a rolling 7-day window
- recovery_rate — share of failed tasks that succeeded after retry
- context_efficiency — output tokens as a fraction of total tokens
- cost_per_outcome — total cost divided by completed tasks
Generate an outcome report
Dispatch conductor-outcome-collector after workflow completion. It reads conductor state, Gemini validations and governance audit events, then computes the metrics above.
Predictive Scaling
What it does
Workload pattern analysis from stored trajectories, driving adaptive model routing, cache pre-warming and cost forecasting with confidence intervals. Statistical analysis only — no ML training.
Get a routing decision
curl -X POST http://localhost:8097/economics/route \
-H "Authorization: Bearer {token}" \
-H "Content-Type: application/json" \
-d '{ "task_type": "code_generation", "complexity": "medium" }'Routing history and manual overrides are available at /economics/routing/history and /economics/routing/override.
Forecast cost
Dispatch conductor-prediction-engine to get cost projections with confidence intervals based on the current trajectory.
A2A Agent Interoperability
What it does
A FastAPI gateway on port 8100 that exposes an explicit allowlist of agents to external callers over REST, an MCP bridge, and the Google A2A protocol. The registry file is the allowlist: an agent not listed there is not reachable.
What ships in the box
The default registry/capabilities.yaml is a worked example containing three generic agents — a reviewer, a researcher and a builder — which you replace with your own. A larger real-world registry wiring up the 15 externally-callable conductor agents is included at examples/capabilities.conductor.yaml. Point the gateway at any registry with A2A_REGISTRY_PATH.
Connect it to your agent runtime
The gateway is runtime-agnostic. A2A_INVOKER_TEMPLATE is the command line it runs to invoke an agent, with {agent_id} and {prompt} substituted after tokenization:
A2A_INVOKER_TEMPLATE='my-agent-cli --name {agent_id} --prompt {prompt}'Discover available agents
curl http://localhost:8100/.well-known/agent.jsonReturns a Google A2A-compliant Agent Card describing every exposed agent, its capabilities, authentication requirements and rate limits.
Invoke an agent
curl -X POST http://localhost:8100/api/v1/agents/example-reviewer/invoke \
-H "X-API-Key: {key}" \
-H "Content-Type: application/json" \
-d '{"prompt": "Review this diff", "caller_id": "ext-001"}'Returns {job_id, status}. Poll for the result with GET /api/v1/jobs/{job_id}. Agents marked elevated additionally require an X-Trust-Level: elevated header.
Regulatory Compliance & Audit Trail
What it does
A cryptographically-chained immutable audit log, versioned and signed evidence packages, human decision gates with signed receipts, data-subject-request handling and incident tracking. The service runs on port 8088; non-public routes require a COMPLIANCE_API_TOKEN.
Framework coverage
Compliance scores are derived from live governance events and mapped to control domains for six frameworks: iso42001, eu_ai_act, owasp_agentic, soc2, iso27001 and glba. Scores are a saturation curve over the counts of the governance event types mapped to each control domain — a signal derived from real system activity, not a control-by-control attestation.
curl http://localhost:8088/compliance/soc2/scores
curl http://localhost:8088/compliance/iso42001/gapsRecord a chained audit event
curl -X POST http://localhost:8088/audit/events \
-H "Content-Type: application/json" \
-d '{
"audit_type": "tool_use_elevated",
"user_id": "usr-001",
"classification": "confidential",
"payload": { "agent_id": "conductor-builder", "tool": "Edit" }
}'Verify the audit chain
curl http://localhost:8088/audit/verifyWork with evidence packages
curl http://localhost:8088/evidence
curl http://localhost:8088/evidence/{package_id}
curl http://localhost:8088/evidence/{package_id}/verifyPackages are versioned — /evidence/{package_id}/versions lists revisions and /diff compares them. /evidence/coverage reports what the current package set covers.
Submit a data subject request
curl -X POST http://localhost:8088/dsr \
-H "Content-Type: application/json" \
-d '{ "request_type": "erasure", "subject_name": "...", "subject_email": "..." }'Requests move through a tracked lifecycle via /dsr/{id}/transition, with evidence generation and delivery endpoints, plus public status and receipt lookups.
Human decision gates
curl http://localhost:8088/gates
curl -X POST http://localhost:8088/gates/{gate_id}/decide \
-H "Content-Type: application/json" \
-d '{ "decision": "approve", "rationale": "..." }'Each decision produces a signed receipt at /gates/{gate_id}/receipt.
Open an incident
curl -X POST http://localhost:8088/incidents \
-H "Content-Type: application/json" \
-d '{ "classification": "confidential", "trigger_source": "guardian_terminate" }'Incidents support notes, notifications, state transitions, and report generation with a finalize step.