- Home
- Skills
- Agents & Orchestration
- Aegis-Swarm-Kernel
More screenshots
Works with the AI Agents you already use
Aegis-Swarm-Kernel
Deterministic multi-agent orchestrator with hybrid model routing, workspace mutex locks, and cost-control circuit breakers.
$39
Aegis-Swarm-Kernel
Example session with this skill installed
I need to refactor the auth module and update the documentation. Compile a DAG for these tasks and ensure we don't exceed a $0.50 budget.
- Read your context and instructions
- Compiled the aegis-swarm-kernel
I have compiled and validated the execution plan via compile_and_route_dag for the auth-revamp workflow. The dependency graph passed Kahn's topological cycle check, compressed parent-to-child context into structured ContextPacket payloads, and routed each node to its optimal cost-performance tier.
Aegis Swarm Execution Plan: auth-revamp
| Task ID | Title | Assigned Tier | Wave | Est. Cost | Target Files |
|---|---|---|---|---|---|
node_01 | Auth Logic Refactor | FRONTIER_CLOUD | 1 | $0.120 | src/auth.py |
node_02 | Unit Test Suite Update | LOCAL_WORKER | 2 | $0.000 | tests/test_auth.py |
node_03 | API Documentation Sync | FAST_CLOUD | 2 | $0.015 | docs/api.md |
Routing & Financial Governance Summary
- Total Estimated Cost: $0.135 USD
- Budget Ceiling: $0.500 USD (73% headroom remaining)
- Unconstrained Baseline (All-Frontier): $0.620 USD
- Projected Cost Savings: $0.485 USD (78.2% reduction)
Next Steps
1.
Acquire Mutex Lock & Execute node_01: Calling acquire_workspace_lock on src/auth.py (TTL 120s) before dispatching the refactor on FRONTIER_CLOUD to prevent parallel write collisions.
2.
Shadow Quarantine & Wave 2 Dispatch: Once node_01 passes submit_node_artifact (Python AST verification + 8-pattern secret/PII scrubbing), Wave 2 will dispatch node_02 (LOCAL_WORKER) and node_03 (FAST_CLOUD) in parallel.
3.
Live Telemetry: Query get_swarm_telemetry or read aegisswarm://telemetry at any point to audit USD burn, token compression, and SHA-256 loop breaker status.
Connects securely to your tools. The creator never sees your data.
About this skill
Large-scale multi-agent workflows often collapse due to token-heavy chat histories, runaway API costs, and parallel write race conditions. This skill provides a deterministic control plane to manage sub-agent execution, budgets, and workspace integrity.
What it does
- Deterministic DAG Orchestration validates task dependencies and produces parallel execution waves using Kahn's algorithm.
- Hybrid Model Routing assigns tasks to Frontier, Fast, or Local tiers to optimize spend based on task complexity.
- Atomic Workspace Locking prevents sub-agents from overwriting the same files simultaneously with mutex locks.
- Shadow Quarantine Gate verifies artifact syntax and scrubs PII or secrets before promotion to the codebase.
- Loop & Budget Protection triggers circuit breakers on repetitive errors or when USD/token caps are breached.
- Context Compression reduces $O(N^2)$ token explosion by passing minimal ContextPackets instead of raw chat transcripts.
How it works
- Compile: Submit a multi-step plan to
compile_and_route_dagto generate a dependency graph and budget estimate. - Lock: Sub-agents call
acquire_workspace_lockbefore attempting to modify specific file paths. - Execute: Dispatch tasks to the recommended model tiers using compressed context handoffs.
- Verify: Submit results to
submit_node_artifactfor AST/JSON validation and secret scrubbing. - Recover: Use
record_swarm_failureto distill failure rules into shared memory and handle rate-limit fallbacks.
Frameworks & tools
This kernel interfaces with Qdrant for shared procedural memory and uses Python AST/JSON grammars for artifact validation. It is compatible with Claude Code, Cursor, and standard MCP environments.
Why this beats prompting it yourself
Manual prompting cannot enforce atomic file locks or deterministic acyclic graphs across independent agent instances. This skill replaces vague "work together" instructions with a hard L7 protocol that saves up to 80% on tokens through structured handoffs and tiered routing.
Use cases
- Parallel Refactoring where multiple agents edit a large codebase without collision.
- Budget-Capped Dev to prevent autonomous agents from burning Frontier model credits on boilerplate.
- Automated PR Review ensuring all generated code passes syntax and security gates before submission.
- Reliable Handoffs where specialized sub-agents receive only the context relevant to their specific node.
Known limitations
Requires a Python environment to run the server. Syntax verification is currently scoped to Python and JSON formats.
AST syntax verification supports Python (.py) and JSON (.json) artifacts natively; other file types pass secret/PII scrubbing and schema checks without AST parsing. Runs in-memory Qdrant by default (non-persistent across server restarts unless external Qdrant is configured). Cost calculations use configurable per-1M token estimates.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 3 days ago
Requires
Permissions
Allowed Hosts
File Scopes
Read Files is used strictly inside the Shadow Quarantine Gate to verify Python AST syntax, JSON schemas, and scrub 8 secret/PII patterns before releasing transactional file locks. Environment Variables configure USD/token caps, lock TTLs, and Qdrant memory settings. Network access is disabled unless optional SSE transport is enabled.