Agent Farm

🚀 Agent Farm v3.4 - Chunked Write Edition

AI organism evolution and parallel task execution with tool-enabled agents. Now with the Chunked Write Pattern for generating large documents and code files!

🚀 Quick Start

Agent Farm v3.4 offers advanced AI organism evolution and parallel task execution capabilities. The new Chunked Write Pattern allows for the generation of large documents and code files, bypassing the traditional output limitations.

✨ Features

What's New in v3.4

• Chunked Write Pattern: Bugs write sections in parallel, and Python assembles the results directly.
• chunked_write: Generate large markdown/text documents of unlimited size.
• chunked_code_gen: Generate multi - function code files in parallel.
• chunked_analysis: Conduct multi - perspective analysis with synthesis.
• Bypasses 500 - char limit: Each bug writes small chunks, and the combined output is unlimited.

Performance

• 8.6x faster than v3.0 (103s -> 12s for a 4 - task swarm).
• 1 iteration per task (previously 3 - 5).
• 100% success rate with real tool data.
• Local synthesis - qwen2.5:14b synthesizes results (no cloud tokens required).

📦 Installation

cd ~/repos/agent-farm
uv venv
uv pip install -e .

💻 Usage Examples

System Health Check

agent-farm:system_health_swarm

Custom 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: A 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: 4

Output: A 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: 4

Output: Analysis from Structure, Patterns, Quality, Performance perspectives

📚 Documentation

Models

MCP Tools (30)

Colony Management

• spawn_colony - Create a bug colony (standard/fast/heavy/hybrid)
• list_colonies - List active colonies
• colony_status - Get detailed colony info
• quick_colony - Perform a quick health check
• dissolve_colony - Remove a colony
• cleanup_idle - Remove idle colonies
• farm_stats - Get comprehensive statistics

Swarm Deployment

• deploy_swarm - Deploy tasks to a colony
• quick_swarm - One - shot spawn + deploy

Specialized Swarms

• code_review_swarm - Conduct a 4 - perspective code review
• code_gen_swarm - Generate code + tests + docs
• file_swarm - Perform parallel file operations
• exec_swarm - Execute parallel shell commands
• api_swarm - Make parallel HTTP requests
• kmkb_swarm - Conduct multi - angle knowledge queries

Tool - Enabled Agents

• tool_swarm - Deploy bugs with real system tools
• system_health_swarm - Perform a quick system health check
• recon_swarm - Conduct directory/codebase reconnaissance
• deep_analysis_swarm - Perform deep disk/file analysis
• worker_task - Assign a single worker with full tools

Direct Operations

• heavy_write - Write directly to a file (bypasses LLM for large content)
• synthesize - Perform standalone synthesis of any JSON results

Chunked Write Pattern (NEW)

• chunked_write - Generate large documents via parallel section writing
• chunked_code_gen - Generate code files with functions written in parallel
• chunked_analysis - Conduct multi - perspective analysis with synthesis

Bug Tool Permissions

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 enforced
• structured+autoformat - JSON + simple result formatting
• structured+deep - JSON with multi - step reasoning
• regex - Fallback regex parsing
• regex+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:14b)
   |-- Creates structured JSON outline
   |-- {"sections": [{"title": "...", "description": "..."}]}

2. WORKER BUGS (qwen3:4b) - 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 corruption

Performance

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.

Claude Desktop Config

{
  "mcpServers": {
    "agent-farm": {
      "command": "/home/kyle/repos/agent-farm/.venv/bin/python",
      "args": ["-m", "agent_farm.server"]
    }
  }
}

📄 License

No license information provided in the original document.

🔧 Technical Details

The system uses Ollama's structured output feature for JSON schema enforcement. Constrained decoding (GBNF grammar) is used to mask invalid tokens during generation, ensuring valid JSON output. The chunked write pattern decomposes large tasks to bypass the output limitations of small models, with parallel execution and Python - based assembly.

📚 Changelog

v3.4.0 (2026 - 01 - 23)

• Chunked Write Pattern - Bugs write sections in parallel, and Python assembles the results.
• chunked_write - Generate unlimited - size documents (tested: 9.6KB in 78s).
• chunked_code_gen - Generate multi - function code files in parallel.
• chunked_analysis - Conduct multi - perspective analysis with synthesis.
• Bypass the 500 - char bug limitation via task decomposition.
• The planner uses structured JSON output for reliable outlines.

v3.3.0 (2026 - 01 - 23)

• Ollama Structured Output - Enforce JSON schemas via constrained decoding.
• Reliable tool parsing - Eliminate regex failures.
• Mode tracking - Results show the parsing method used.
• Regex fallback - Legacy parsing is still available as a backup.
• All roles can use exec_cmd for complex shell queries.

v3.2.0 (2026 - 01 - 22)

• Synthesizer role - Use qwen2.5:14b for accurate result synthesis.
• synthesize parameter - Added to tool_swarm, system_health_swarm, recon_swarm, deep_analysis_swarm.
• synthesize tool - Perform standalone synthesis of any JSON results.
• No more Claude synthesis tax - Bugs perform all work locally.

v3.1.0 (2026 - 01 - 20)

• 8.6x speed improvement (103s -> 12s).
• Auto - format results to skip redundant LLM calls.
• Reject invalid tools instantly.
• Force tool usage before providing answers.
• Fix complex shell command support.
• Upgrade all roles to at least qwen3:4b.

v3.0.0 (2026 - 01 - 19)

• Rebuild from the Windows version for Linux.
• Introduce tool - enabled agents with role permissions.
• Implement system health, recon, and worker swarms.
• Achieve true parallel execution via ThreadPoolExecutor.