Agent Farm
Agent Farm is a local MCP server for spawning parallel AI “bug” colonies that perform filesystem, command, HTTP, code-generation/review, analysis, and synthesis tasks on trusted inputs.
Spawn, list, inspect, dissolve, and clean up colonies; view colony and farm statistics.
Deploy custom or one-shot swarms for parallel prompts, file operations, shell commands, HTTP API calls, and KMKB queries.
Run specialized swarms for code review, code generation, system health, reconnaissance, and deep disk/file analysis.
Use role-based tool-enabled agents with permissions for file reads/writes, command execution, HTTP access, system checks, code analysis, and knowledge-base queries.
Generate large documents, multi-function code files, and multi-perspective analyses via the chunked write pattern with local Python assembly.
Directly write large content without an LLM and synthesize JSON results into unified summaries.
Rely on security guards such as shell-free exec, path allowlists, SSRF protection, API mutation opt-in, concurrency/output limits, and optional action logging; it is not a sandbox and is intended for trusted local use.
Enables monitoring of Docker services as part of automated system health and status checks.
Provides comprehensive tools for Linux system administration, including monitoring system status, disk usage, and service health, as well as performing directory and codebase reconnaissance.
Supports the parallel generation of large Markdown documents and security guides using a specialized chunked writing pattern to bypass model output limits.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Agent Farm Generate a large technical manual for my API using the chunked write pattern"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Agent Farm v3.4 - Chunked Write Edition
AI organism evolution and parallel task execution with tool-enabled agents. Now with Chunked Write Pattern for generating large documents and code files!
What's New in v3.4
Chunked Write Pattern: Bugs write sections in parallel, Python assembles directly
chunked_write: Generate large markdown/text documents (unlimited size)
chunked_code_gen: Generate multi-function code files in parallel
chunked_analysis: Multi-perspective analysis with synthesis
Bypasses 500-char limit: Each bug writes small chunks, combined output is unlimited
Related MCP server: JustClone Coordination MCP Server
Performance
Parallel execution via ThreadPoolExecutor (no measured speedup claim is made)
1 iteration per task (was 3-5)
Local synthesis - qwen3:30b-a3b-q3k synthesizes results (no cloud tokens!)
Security
This server runs commands (exec_cmd, exec_swarm) and file operations
on the local machine. It is not a sandbox: allowed programs still run
with the server's privileges, so it cannot make LLM-generated commands
safe against untrusted input. Run it locally, with trusted prompts only,
and do not expose it to untrusted files, web pages, or other users'
prompts.
Security model
The guards in place today, in one place:
Filesystem: reads are blocked for system/sensitive paths and writes are allowed only inside
/tmp,/home/kyle/repos,/home/kyle/Desktop, and the platform's system temp directory (on Linux that is/tmpalready; on Windows it is the user's Temp folder, and it is only added when it sits under a well-known temp location (/tmp,/var/tmp, or the Windows Temp folders), never a home dir, a drive root, or any other folder a TEMP setting points at). Paths are checked after resolving symlinks and..components, so prefix look-alikes and symlink tricks do not bypass them.HTTP / SSRF: only public http/https URLs are fetched, each validated once and then connected to that exact validated IP (IP pinning), with redirects re-validated hop by hop. URLs with login details in them are always rejected.
Exec: no shell at all. Only simple commands (argument lists) or safe pipelines (stages joined by a single
|, max 5 stages) run. Chaining, redirection, substitution, and backgrounding are rejected. A command blocklist remains only as defence-in-depth.api_swarm: GET-only by default. POST/PUT/DELETE need an explicit per-call
allow_mutating=True; there is no server-wide flag that silently enables mutation for later calls. Making mutation structurally impossible would break this tool's intended purpose (calling APIs), so the safe default + per-call opt-in + action logging is the design instead.Parallel work: at most 32 items per request, 100,000-character payloads, 50,000-character aggregate output, per-task timeouts, and at most 4 simultaneous model calls.
Generated code:
chunked_code_genfor Python compiles and checks the assembled file and reportsvalidatedorwritten_not_validated; validation never runs the code, so it is not a claim the code was tested or is correct.
Deployment: safe defaults
Defaults are deny/off: private-HTTP escape hatches are off unless explicitly set, and
api_swarmmutation is off unless explicitly passed per call.Local testing only, never in production:
AGENT_FARM_ALLOW_PRIVATE_HTTP=1andAGENT_FARM_ALLOWED_HTTP_HOSTS=host1,host2relax only the private-IP rule; scheme and credential checks still apply, and allowed hosts must still resolve.Set
AGENT_FARM_PRODUCTION=1in any production-like deployment: it ignores both escape hatches entirely, even if a test setting was left in the environment.Use
tools.get_security_config()to inspect the current configuration, andtools.escape_hatches_active()to see whether any escape hatch is currently in effect.
Action log (structured, opt-in)
Set AGENT_FARM_ACTION_LOG=/path/to/actions.jsonl (or =1 for
./agent-farm-actions.jsonl) to record one JSON object per line
for enforcement events: blocked paths, blocked URLs, blocked
commands, blocked/allowed mutating API calls, timeouts, and code
validation outcomes. It never logs message bodies, file contents,
generated code, full command lines (binary name only), or URLs
with credentials (those are redacted). Each record carries a
SHA-256 hash chain (prev_hash / hash); action_log.verify_action_log(path)
detects a single record edited in place. That is not
tamper-proofing: anyone with write access to the log file could
rewrite the whole chain. The log is off by default.
Hardening in place:
HTTP SSRF guard:
http_get/http_postnow allow only public http/https URLs. Private, loopback, link-local, and metadata addresses (including127.0.0.1and169.254.169.254) are blocked, DNS failures fail closed, and redirects are re-validated hop by hop. Each validated URL is then connected to the exact IP that was validated (IP pinning), with the original hostname kept for the Host header and, for https, TLS certificate verification, so a DNS answer cannot change between the check and the connection. For local testing only,AGENT_FARM_ALLOW_PRIVATE_HTTP=1orAGENT_FARM_ALLOWED_HTTP_HOSTS=host1,host2can relax ONLY the private-IP rule; scheme validation and credential rejection still apply, and allowed hosts must still resolve. The internal KMKB client (127.0.0.1:8765) does not go through these tools.No shell at all:
exec_cmdnever runs a shell. Simple commands run as argument lists, and the only complex form allowed is a safe pipeline (stages joined by a single|, each stage an argument list, max 5 stages). Chaining (;,&&,||), redirection (>,<), substitution ($(...), backticks,${...}), backgrounding (&), and multi-line commands are rejected. This is a breaking change for commands that relied on shell chaining or redirection: use separateexec_cmdcalls, andwrite_fileinstead of shell redirection.Tests and CI: see Testing below. CI runs compile checks and pytest on push and pull requests to
main.Swarm tools use the same guards:
exec_swarmnow delegates totool_exec_cmdandapi_swarmnow delegates to the shared HTTP helper, so neither can bypass the exec or SSRF guards above.Parallel reliability limits: parallel tools (
exec_swarm,api_swarm,file_swarm,kmkb_swarm,tool_swarm,deploy_swarm,quick_swarm) accept at most 32 items per request and a 100,000-character payload; an empty or non-array list is rejected instead of creating a zero-worker pool. Each task has a per-task timeout, and total parallel output is capped at 50,000 characters (output_truncated: truewhen the cap bites). Model calls are gated to at most 4 at once, shared across tools.Blocking work stays off the async event loop: async tools run blocking model, file, and swarm work in threads (
asyncio.to_thread), so one long model call does not stall other requests. A per-task timeout means the caller stops waiting; it does not kill a thread already running.Generated code is validated, not just written:
chunked_code_genfor Python now compiles the assembled file and reports duplicate top-level function names, syntax errors, and failed generation fragments before declaring it complete. A result ofvalidatedmeans it compiles cleanly;written_not_validatedmeans the file was saved but did not pass validation (or, for non-Python languages, validation is not implemented). Validation never runs the generated code, so it is not a claim that the code was tested or is correct.Server layout:
server.pyis now a thin entrypoint. Tools live instate.py(model tiers, colonies, stats),ollama.py,colony.py,colony_tools.py,swarm_tools.py, andchunked_tools.py. The 25 MCP tool names are unchanged, andserver.pyre-exports them.
Testing
pip install .[dev]
python -m pytest -qTests in tests/test_tools.py cover path safety and symlink traversal,
write-allowlist prefix lookalikes, exec blocklist variants and
shell-free execution, HTTP SSRF guards (with mocked DNS), tool-call
parsing (JSON, quoted commas, parentheses), and ID uniqueness.
Tests in tests/test_chatgpt_top_security.py cover the ChatGPT-review
fixes: the private-HTTP override, DNS rebinding / IP pinning (including
a local-server test where DNS flips after validation), and safe
pipelines vs. rejected shell operators.
Tests in tests/test_chatgpt_medium_reliability.py cover the
ChatGPT-review medium findings: parallel input limits and output
caps, per-task timeouts, the shared model-concurrency gate, Python
code validation (syntax, duplicates, possible missing imports),
written-vs-validated code generation, and that a slow blocking
planner does not stall the async event loop.
Models
Role | Model | VRAM | Purpose |
Scout | qwen3:4b | 2.5GB | Reconnaissance |
Worker | qwen2.5-coder:7b | 4.7GB | Task execution (code-tuned) |
Memory | qwen3:4b | 2.5GB | Context retention |
Guardian | qwen3:4b | 2.5GB | System monitoring |
Learner | qwen2.5-coder:7b | 4.7GB | Pattern acquisition (code-tuned) |
Synthesizer | qwen3:30b-a3b-q3k | 14.7GB | Result synthesis |
Prerequisite: pull the synthesizer model before upgrading, or synthesis and code review fail with a model-not-found error:
ollama pull qwen3:30b-a3b-q3k(14.7GB).
Code review, code generation, and KMKB synthesis use the synthesizer tier, not a separate model.
MCP Tools (25)
Colony Management
spawn_colony- Create bug colony (standard/fast/heavy/hybrid)list_colonies- List active coloniescolony_status- Detailed colony infoquick_colony- Quick health checkdissolve_colony- Remove colonycleanup_idle- Remove idle coloniesfarm_stats- Comprehensive statistics
Swarm Deployment
deploy_swarm- Deploy tasks to colonyquick_swarm- One-shot spawn + deploy
Specialized Swarms
code_review_swarm- 4-perspective code reviewcode_gen_swarm- Generate code + tests + docsfile_swarm- Parallel file operationsexec_swarm- Parallel shell commandsapi_swarm- Parallel HTTP requestskmkb_swarm- Multi-angle knowledge queries
Tool-Enabled Agents
tool_swarm- Deploy bugs with real system toolssystem_health_swarm- Quick system health checkrecon_swarm- Directory/codebase reconnaissancedeep_analysis_swarm- Deep disk/file analysisworker_task- Single worker with full tools
Direct Operations
heavy_write- Direct file write (bypasses LLM for large content)synthesize- Standalone synthesis of any JSON results
Chunked Write Pattern (NEW)
chunked_write- Generate large documents via parallel section writingchunked_code_gen- Generate code files with functions written in parallelchunked_analysis- Multi-perspective analysis with synthesis
Bug Tool Permissions
Role | Tools |
Scout | read_file, list_dir, file_exists, system_status, process_list, disk_usage, check_service, exec_cmd |
Worker | read_file, write_file, list_dir, exec_cmd, http_get, http_post, system_status, disk_usage, check_service |
Memory | read_file, kmkb_search, kmkb_ask, list_dir, system_status, process_list, disk_usage, check_service, exec_cmd |
Guardian | system_status, process_list, disk_usage, check_service, read_file, list_dir, exec_cmd |
Learner | read_file, analyze_code, list_dir, kmkb_search, system_status, process_list, disk_usage, check_service, exec_cmd |
Structured Output Details
Agent Farm v3.3 uses Ollama's structured output feature to enforce JSON schemas on model responses:
# Bug responds with guaranteed-valid JSON:
{"tool": "system_status", "arg": ""}
{"tool": "exec_cmd", "arg": "df -h"}
{"tool": "check_service", "arg": "ollama"}The constrained decoding (GBNF grammar) masks invalid tokens during generation, ensuring:
Always valid JSON
Correct tool names
Proper argument structure
No parsing failures
Results now include a mode field showing which method was used:
structured- JSON schema enforcedstructured+autoformat- JSON + simple result formattingstructured+deep- JSON with multi-step reasoningregex- Fallback regex parsingregex+autoformat- Regex + simple result formatting
Chunked Write Pattern
The chunked write pattern solves the ~500 char output limitation of small models by decomposing large tasks:
1. PLANNER BUG (qwen2.5-coder:7b-v8-review)
|-- Creates structured JSON outline
|-- {"sections": [{"title": "...", "description": "..."}]}
2. WORKER BUGS (qwen2.5-coder:7b-v8-review) - IN PARALLEL
|-- Each writes one section (~300-500 chars)
|-- 4 workers = 4 sections simultaneously
3. PYTHON CONCATENATION (NO LLM)
|-- header + separator.join(sections)
|-- Zero token cost, instant assembly
4. DIRECT FILE WRITE (NO LLM)
|-- tool_write_file() saves result
|-- Bypasses any output corruptionPerformance
Tool | Output Size | Sections | Time |
chunked_write | 9.6 KB | 5 | 78s |
chunked_code_gen | 1.9 KB | 4 functions | 88s |
chunked_analysis | Varies | 4 perspectives | ~60s |
Why It Works
Small models excel at focused, short outputs
Each section is within the "safe zone" (<500 chars)
Python handles assembly (no LLM token cost)
Parallel execution via ThreadPoolExecutor
Structured output ensures reliable planning
Usage Examples
System Health Check
agent-farm:system_health_swarmCustom Task Swarm
agent-farm:tool_swarm
colony_type: "heavy"
tasks: [
{"prompt": "Check CPU temperature"},
{"prompt": "List top 5 memory processes"},
{"prompt": "Check if docker is running"}
]Large File Write (Direct)
agent-farm:heavy_write
path: "/tmp/large_output.txt"
content: "... large content ..."Codebase Reconnaissance
agent-farm:recon_swarm
target_path: "/home/kyle/repos/my-project"Generate Large Document (Chunked)
agent-farm:chunked_write
output_path: "/tmp/security_guide.md"
spec: "Linux server security hardening guide"
num_sections: 5
doc_type: "markdown"Output: 9KB+ document with 5 coherent sections
Generate Code File (Chunked)
agent-farm:chunked_code_gen
output_path: "/tmp/utils.py"
spec: "File utilities: read, write, copy, delete"
language: "python"
num_functions: 4Output: Complete Python module with 4 functions
Multi-Perspective Analysis
agent-farm:chunked_analysis
target: "/home/kyle/repos/project"
question: "What are the architectural patterns?"
num_perspectives: 4Output: Analysis from Structure, Patterns, Quality, Performance perspectives
Installation
cd ~/repos/agent-farm
uv venv
uv pip install -e .Claude Desktop Config
{
"mcpServers": {
"agent-farm": {
"command": "/home/kyle/repos/agent-farm/.venv/bin/python",
"args": ["-m", "agent_farm.server"]
}
}
}Changelog
Changes included in this clean rebuild
Removed a workflow script that hardcoded a credential (see the pull request description: removing it from a branch does NOT purge git history; rotate the key if it was real) and deleted the broken OpenAI workflow that ran a nonexistent root-level main.py. A replacement compile-check workflow could not be created through the GitHub App (403 on workflow files) and can be added manually after review if wanted.
Path checks now use canonical, symlink-resolved paths with commonpath matching, applied to file reads, writes, listings, existence checks, disk usage, and file_swarm operations; write-dir matching no longer lets "/tmpfoo" pass as "/tmp".
Expanded the exec-command blocklist and documented that it is not a sandbox; the server is for local, trusted use only.
Colony and bug IDs are now uuid-based instead of second-resolution timestamps, so duplicate roles and same-second spawns cannot collide.
Write tasks with path + content are direct-executed at any length; short writes are no longer silently dropped.
file_swarm workers are capped at 8 and results are returned in input order.
Removed the derived (circular) parallel-speedup calculation; no speedup is reported unless it is actually measured.
Version aligned to 3.4.0 across pyproject, tools, and package init; the MCP tool count is corrected to 25 (counted from server.py).
Tool-call parsing now handles quoted arguments containing commas and JSON object arguments, without breaking the TOOL: name(args) format.
Dependencies in pyproject are now bounded (mcp <2, httpx <1, psutil <8); fastmcp stays pinned at 3.2.0.
v3.4.0 (2026-01-23)
Chunked Write Pattern - Bugs write sections in parallel, Python assembles
chunked_write - Generate unlimited-size documents (tested: 9.6KB in 78s)
chunked_code_gen - Generate multi-function code files in parallel
chunked_analysis - Multi-perspective analysis with synthesis
Bypasses 500-char bug limitation via task decomposition
Planner uses structured JSON output for reliable outlines
v3.3.0 (2026-01-23)
Ollama Structured Output - JSON schema enforcement via constrained decoding
Reliable tool parsing - No more regex failures
Mode tracking - Results show parsing method used
Regex fallback - Legacy parsing still available as backup
All roles get exec_cmd for complex shell queries
v3.2.0 (2026-01-22)
Synthesizer role - qwen3:30b-a3b-q3k for accurate result synthesis
synthesize parameter - Added to tool_swarm, system_health_swarm, recon_swarm, deep_analysis_swarm
synthesize tool - Standalone synthesis of any JSON results
No more Claude synthesis tax - bugs do ALL the work locally
v3.1.0 (2026-01-20)
8.6x speed improvement (103s -> 12s)
Auto-format results skip redundant LLM calls
Reject invalid tools instantly
Force tool usage before answers
Complex shell command support fixed
All roles upgraded to qwen3:4b minimum
v3.0.0 (2026-01-19)
Linux rebuild from Windows version
Tool-enabled agents with role permissions
System health, recon, worker swarms
TRUE PARALLEL via ThreadPoolExecutor
License
This project is licensed under the Apache License, Version 2.0. See the LICENSE file for the full text.
Copyright 2026 BossX429
Clean rebuild note
This is a clean rebuild of agent-farm v3.4.0, based on the fixed code from BossX429/agent-farm main after PR #5 was merged. It contains no prior git history, no broken workflow files, and no credential files.
Available Tools
25 toolsapi_swarmC
Execute parallel HTTP API requests.
requests: JSON array of {url, method?, headers?, body?}
Example: [{"url": "https://api.example.com/data"}, {"url": "...", "method": "POST", "body": "{}"}]
Inputs: requests (required).
chunked_analysisB
Analyze something from multiple perspectives in parallel.
Each bug analyzes from a different angle, results are synthesized.
target: What to analyze (file path, concept, code, etc.)
question: The analysis question
num_perspectives: How many different angles (default 4)
EXAMPLE:
chunked_analysis("/home/kyle/repos/project", "What are the main architectural patterns?", 4)
Inputs: target (required), question (required), num_perspectives.
chunked_code_genB
Generate code files by having bugs write functions in parallel.
Each bug writes one function, Python assembles the file.
output_path: Where to save the code file
spec: What the code should do
language: 'python', 'javascript', 'bash', etc.
num_functions: How many functions to generate (default 4, max 8)
EXAMPLE:
chunked_code_gen("/tmp/utils.py", "File utilities: read, write, copy, delete", "python", 4)
Inputs: output_path (required), spec (required), language, num_functions.
chunked_writeA
Generate large documents by having bugs write sections in parallel.
Bypasses the long-content limitation by chunking work.
HOW IT WORKS:
1. Planner bug creates outline (structured JSON)
2. Worker bugs generate sections in PARALLEL
3. Python concatenates directly (NO LLM involved)
4. heavy_write saves result
output_path: Where to save the document
spec: What the document should be about
num_sections: How many sections (default 5, max 10)
doc_type: 'markdown', 'text', or 'code'
EXAMPLE:
chunked_write("/tmp/report.md", "Analysis of Python best practices", 5)
Inputs: output_path (required), spec (required), num_sections, doc_type.
cleanup_idleB
Remove all colonies with 0 tasks completed
Inputs: no named parameters.
code_gen_swarmC
Generate code from spec with 4 parallel perspectives.
Returns: main code, tests, docstring, usage examples.
Inputs: spec (required), language.
code_review_swarmB
Run parallel code review with 4 specialized perspectives.
Pass code directly OR filepath to read from disk.
Returns: security, performance, style, and refactoring analysis.
Inputs: code (required), filepath.
colony_statusC
Get detailed status of a specific colony
Inputs: colony_id (required).
deep_analysis_swarmB
Deep analysis swarm using WORKERS with exec_cmd for thorough system analysis.
Workers can run shell commands (find, du, grep, etc.) for real analysis.
target_path: Directory/path to analyze
analysis_type: 'full', 'redundant', 'sizes', 'cleanup'
synthesize: If True (default), uses qwen2.5:14b to synthesize findings
Use this for finding: redundant files, cache sizes, disk usage, log files, etc.
Inputs: target_path (required), analysis_type, synthesize.
deploy_swarmC
Deploy swarm for parallel task execution.
tasks: JSON array of {prompt, context?} objects
Example: [{"prompt": "analyze X"}, {"prompt": "summarize Y", "context": "..."}]
Inputs: colony_id (required), tasks (required).
dissolve_colonyB
Dissolve a colony and free resources
Inputs: colony_id (required).
exec_swarmA
Execute shell commands in parallel (with safety checks).
commands: JSON array of command strings
Example: ["ls -la", "pwd", "whoami"]
BLOCKED: rm -rf, sudo, dd, mkfs, chmod 777, etc.
Inputs: commands (required).
farm_statsC
Get comprehensive farm statistics
Inputs: no named parameters.
file_swarmC
Execute parallel file operations.
operations: JSON array of {action, path, content?}
Actions: read, write, append, exists, delete
Example: [{"action": "write", "path": "/tmp/test.txt", "content": "hello"}]
Inputs: operations (required).
heavy_writeA
Direct file write - NO LLM involved. Use for large content.
Bugs can't reliably echo content >300 chars through the LLM.
This tool writes directly to disk, bypassing the model entirely.
path: File path to write to
content: Content to write (any length)
Returns: success/error status and bytes written
Inputs: path (required), content (required).
kmkb_swarmC
Query KMKB from multiple angles in parallel, optionally synthesize.
queries: JSON array of query strings OR single topic to auto-expand
Example: ["what is X?", "how does X work?", "examples of X"]
Or just: "Agent Farm" (auto-expands to multiple queries)
Inputs: queries (required), synthesize.
list_coloniesB
List all active colonies with their bugs
Inputs: no named parameters.
quick_colonyB
Quick status check - ONE CALL for colony health
Returns: verdict, issues, active colonies, stats
Inputs: no named parameters.
quick_swarmC
One-shot: spawn colony + deploy swarm + return results
tasks: JSON array or single prompt string
Inputs: tasks (required), colony_type.
recon_swarmB
Reconnaissance swarm - scouts explore a directory/codebase.
Uses scout bugs with read-only tools to map out a target.
target_path: Directory to explore
deep: Enable deep work mode (default False) - multi-iteration for complex analysis
synthesize: If True (default), uses qwen2.5:14b to synthesize findings into unified report
Inputs: target_path (required), deep, synthesize.
spawn_colonyB
Spawn a new bug colony. Types: standard, fast, heavy, hybrid
- standard: scout, worker, worker, memory
- fast: scout, scout, worker, worker (speed)
- heavy: memory, memory, learner, guardian (power)
- hybrid: all roles balanced
Inputs: colony_type.
synthesizeB
Standalone synthesis tool - synthesize any JSON results into unified summary.
Uses qwen2.5:14b for accuracy.
results: JSON array of result objects (with 'answer' or 'response' keys)
context: Optional context about what these results are from
Example: synthesize('[{"answer": "CPU at 5%"}, {"answer": "Memory at 20%"}]', "health check")
Inputs: results (required), context.
system_health_swarmC
Quick system health check using tool-enabled bugs.
Deploys guardian bugs to check CPU, memory, disk, and services.
synthesize: If True (default), uses qwen2.5:14b to synthesize results into unified summary
Inputs: synthesize.
tool_swarmA
Deploy tool-enabled agents that can use real system tools.
Each bug role has different tool permissions:
- scout: read_file, list_dir, file_exists, system_status, process_list
- worker: read_file, write_file, exec_cmd, http_get, http_post
- memory: read_file, kmkb_search, kmkb_ask, list_dir
- guardian: system_status, process_list, disk_usage, check_service
- learner: read_file, analyze_code, list_dir, kmkb_search
tasks: JSON array of task objects:
Standard: {"prompt": "Do something"}
Write: {"path": "/file.txt", "content": "data..."} <-- DIRECT EXECUTE for long content
Example: [{"prompt": "Check system health"}, {"path": "/tmp/out.txt", "content": "results"}]
DIRECT EXECUTE: Write tasks with content >300 chars bypass LLM entirely.
Bugs can't reliably echo long content - we write directly instead.
deep: Enable deep work mode - bugs chain multiple tool calls for complex tasks
synthesize: If True, uses qwen2.5:14b to synthesize results into unified summary
Inputs: tasks (required), colony_type, deep, synthesize.
worker_taskC
Single worker bug with tools to complete a task.
Worker has: read_file, write_file, exec_cmd, http_get, http_post
task: What to do
context: Optional context/background
Inputs: task (required), context.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 25 tools
Multiple tools have overlapping or unclear boundaries, causing ambiguity. For example, 'chunked_analysis', 'deep_analysis_swarm', 'recon_swarm', and 'system_health_swarm' all involve analysis but with vague distinctions in purpose. Similarly, 'deploy_swarm', 'quick_swarm', and 'tool_swarm' all handle task deployment with unclear differences, making it hard for an agent to choose the right one.
The naming conventions are mixed, with some tools using snake_case (e.g., 'api_swarm', 'chunked_analysis') and others using more descriptive phrases (e.g., 'deep_analysis_swarm', 'system_health_swarm'). While there is a general pattern of appending '_swarm' to many tools, it's not consistently applied across all tools, leading to a readable but inconsistent set.
With 25 tools, the count feels excessive for the apparent scope of managing agent colonies and parallel task execution. Many tools seem redundant or overly specialized, such as having separate tools for 'cleanup_idle', 'colony_status', 'list_colonies', and 'quick_colony', which could likely be consolidated into fewer, more general-purpose tools.
The tool set covers a wide range of operations for agent colony management and parallel task execution, including spawning, deploying, monitoring, and synthesizing results. However, there are minor gaps, such as the lack of tools for updating or configuring existing colonies beyond dissolution, and some tools like 'heavy_write' seem redundant with functionality in others like 'tool_swarm'.
Related MCP Connectors
Shared control plane for AI coding agents — tasks, memory, decisions, file locks. 12 tools.
AI work orchestration for plans, tasks, teams, and coding-agent dispatch.
AI agents discuss ideas in Swarms, collaborate on Tasks, and publish attributable Artifacts.
Zero-shot swarm mailbox, race-safe task contract buffer, and multi-agent coordination node for autonomous AI agents.
Related MCP Servers
- AlicenseBqualityDmaintenanceA goal-agnostic parallel orchestration framework that enables sophisticated multi-agent coordination for tasks like code generation, UI development, and research through specification-driven architecture. It utilizes wave-based generation and intelligent context management to execute complex, iterative agentic loops.51MIT
- FlicenseNot gradedqualityNot gradedmaintenanceA production-grade coordination hub that enables AI agents and human teams to work as a single organism by sharing tasks, context, decisions, and persistent memory across projects. It features two-tier agentic memory with per-agent hot caches, inter-agent messaging, and multi-agent authorship tracking for seamless collaboration.2-
- AlicenseNot gradedqualityDmaintenanceEnables multiple LLM agents across devices to form teams, share knowledge, memory, and tasks with live status via a web dashboard and distributed-systems reliability.Apache 2.0
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to operate autonomously with safety, parallelism, and dynamic tool management, without giving them full machine access.1AGPL 3.0