KADATH
An evolutionary multi-agent runtime that breeds, evaluates, and improves autonomous agents across reproducible epochs to converge on a goal.
- Source repo
- i3T4AN/KADATH
- Stars
- ★ 254
- Last updated
- 12d ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 57/100 · Major gaps
At a glance
- How it runs
- Works with
- Platform-specificOpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- High · needs real infrastructure
- You'll need
- Typical use
- Researchers who want to automatically search for optimal prompts, tool combinations, and agent frameworks under reproducible experimental conditions
- Not a fit if
- Users without OpenAI API budget for heavy token spend across many generations
- Projects wanting a lightweight library to embed in existing code
- Teams restricted to non-OpenAI model providers
- Source review
- 57/100 · Major gaps
What does this agent do, and when should you use it?
KADATH (Kernel for Agentic Darwinian Adaptation, Tooling, and Heredity) is an open-source evolutionary multi-agent runtime by i3t4an, released under Apache-2.0. Given a goal, it runs a population of agents across repeated generations, grades them against a locked benchmark, culls weak performers, and breeds children from elites. What evolves is not a response but a complete agent genome: system prompt, Python implementation, tools, dependency declarations, and supporting files, all committed to a run-local bare Git repository. The kernel keeps the evolutionary control plane — grading formulas, scheduling, lineage, and isolation rules — outside the genome so organisms cannot rewrite their own scores or objective. The system deploys as a Docker stack backed by PostgreSQL, MinIO, LiteLLM, and SearXNG, driven by the interactive terminal interface ./kadath.sh. A documented ten-epoch run raised the best top-five score from 18 to 91 and the median from 8 to 77.
You launch ./kadath.sh, enter a goal, epoch duration, population size, and epoch count, and supply an OpenAI API key and model ID. The Architect specialist converts the goal into a machine-readable locked benchmark (score range, weighted rubric, evidence requirements, automatic-failure and anti-fraud rules), which you approve before hashes of the objective and runtime are locked. Each organism is a complete smolagents CodeAgent framework mounted read-only into its own container; it executes in fresh-context passes against a hard deadline, writes to a persistent workspace, calls models through the kernel broker, and can delegate to up to five temporary workers. After execution, the kernel freezes an evidence boundary (512 MiB default ceiling per agent), and the Grader extracts typed facts from that frozen evidence while the kernel itself applies the locked scoring formulas, ignoring agent self-scores. Selection then preserves the top 30% unchanged, lets middle agents reflect and propose mutate or unchanged, culls failures and lowest ranks, and has the Birther produce bounded mutations of elite genomes that inherit memory and durable state. Finished runs export runnable final-population frameworks via ./kadath.sh export RUN_ID.
- Researchers who want to automatically search for optimal prompts, tool combinations, and agent frameworks under reproducible experimental conditions
- Engineers with a quantifiable goal (external benchmark or honest proxy metric) who prefer population competition over single-prompt tuning
- Teams that need systematically compared agent strategies with full lineage, evidence, and score audit trails
- Operators with Docker, PostgreSQL, and MinIO infrastructure who can absorb significant LLM token costs for autonomous experiments
- Users who want to export the best historical genome as a standalone runnable framework and continue evolving from it
How do you install or deploy this agent?
KADATH self-hosts as a Docker stack; first boot generates local PostgreSQL, MinIO, LiteLLM, and SearXNG secrets and prepares images. Clone the repository and run the launcher for first-time configuration:
git clone https://github.com/i3T4AN/KADATH
cd KADATH
./kadath.shOn first launch the interface asks for an OpenAI API key and the OpenAI model ID that will drive the Architect, organisms, Grader, Tweaker, and Birther. Configuration is stored in .kadath/config.env with owner-only permissions. The source documents no installation path other than this Docker-backed launcher.
How do you use this agent?
The normal entry point is the interactive frontend:
./kadath.shArrow keys navigate menus; Ctrl-C exits cleanly. For a new run you enter the goal, epoch duration, population size, and epoch count; after the Architect proposes a benchmark you approve it on the approval screen, which locks objective and runtime hashes and creates generation one. A live dashboard shows epoch progress and leaderboards. Existing runs are managed through the same launcher:
./kadath.sh status RUN_ID
./kadath.sh dashboard RUN_ID --watch
./kadath.sh pause RUN_ID
./kadath.sh resume RUN_ID
./kadath.sh export RUN_ID
./kadath.sh continue RUN_ID --genome GENOME_HASH --epochs 3
./kadath.sh continue-export .kadath/exports/RUN_ID --genome GENOME_HASH --epochs 3
./kadath.sh reset RUN_ID --yes
./kadath.sh cleanup --older-than-days 30After export, winning agents appear in .kadath/exports/RUN_ID/final-population/ as complete runnable framework directories; leaderboards/records.json holds the full ranking and epoch-champions/records.json identifies each epoch's winner.
What are this agent's strengths and limitations?
- The evolutionary control plane lives outside the genome: organisms cannot rewrite their own scores, objective, scheduler, or isolation rules, enforced by hash locks and frozen evidence
- What evolves is a complete editable framework (prompt, source, dependencies, tools), not a single prompt; children breed from the full elite commit
- The README provides quantified proof from a ten-epoch run: best score 18→91, median 8→77, lowest top-five score 1→71
- Fine-grained isolation: read-only root filesystem, non-root user, all capabilities dropped, per-agent rate limits, credentials held only in the control container
- Hard dependency on an OpenAI API key and model; breeding populations across generations can consume substantial tokens and cost
- Heavy deployment: a Docker stack with PostgreSQL, MinIO, LiteLLM, and SearXNG, plus a default 1 CPU / 2 GiB memory per agent
- The documented model path is an OpenAI-compatible gateway (LiteLLM configured with an OpenAI model ID); other providers are not addressed in the source
- The final epoch grades but does not evolve; if every organism fails with no verified genome remaining, the run ends as failed rather than reproducing
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| KADATH This agent | 57 · Major gaps | CLIFree + model costs | ★ 254 | 12d ago | Python | OpenAI API |
| OpenAlpha Evolve | 41 · Major gaps | CLIFree + model costs | ★ 1.1k | 1y ago | Python | OpenAI API · Claude API |
| Hello-Agents | 54 · Major gaps | Web appFree + model costs | ★ 86k | 22d ago | Python | OpenAI API |
| Agent Systems Handbook | 51 · Major gaps | Web appFree | ★ 314 | 19d ago | MDX | — |
How does FollowAgents rate this agent?
Why each dimension lost points
The README thoroughly asserts least-privilege design (read-only root FS, dropped capabilities, non-root, scoped broker tokens, SSRF-guarded HTTP, secret redaction, owner-only config permissions), explicit approval boundaries where declining stops the run, and full snapshot-based rollback; however, all of this is documentation assertion and the kernel source is not present in the evidence, so each earns 2 rather than 3. Deductions: dependencies are declared only as wide ranges (boto3>=1.34 etc.) with no lockfile, SBOM, or vulnerability-management evidence, so dependency_security is 1. Attribution is clear (author i3t4an, smolagents credit, Apache-2.0), but the LICENSE appendix copyright fields are left unfilled.
The README systematically describes crash-restart, grading-interruption recovery, checkpointed specialist work, full selection-phase snapshots with rollback, and per-run file locks, and the narrative is internally consistent; deduction: no dependency lockfile and the runtime requires Docker, PostgreSQL, MinIO, LiteLLM, and SearXNG with no availability evidence, so dependency_availability is 1. failure_messages gets 2 based on described recovery semantics, though only at documentation level.
Audience (advanced users evolving agents toward measurable goals), capability boundaries (512 file ops, 32 MiB content, 2 MiB prompt integrity limits), trigger style (interactive menus with explicit parameter collection), and environment fit (Python>=3.11, Docker/Linux) are all clearly delineated, earning 2 each; not 3 because everything is asserted without accompanying code or config files.
The README is well organized (architecture, flow, isolation, recovery, export, cleanup) with stable naming; deductions: no prerequisites/installation section (first-boot flow is mentioned but not systematically documented), examples_and_faq consists only of screenshots and self-reported results with no FAQ or reproducible example (1), version is 0.1.0 with no CHANGELOG (1), and maintenance is by a single author with no stated update path or contribution process (1). The Apache-2.0 LICENSE is complete but its appendix copyright fields are unfilled, earning 2.
Exported winning agents ship as complete runnable frameworks with manifests and checksums, so output usability is adequate, and the evolutionary multi-agent concept adds marginal value over single-prompt approaches. Deduction: the README admits consuming an 'ungodly number of model tokens' yet offers no cost estimate, consumption range, or cost/benefit discussion, so cost_benefit is 1.
The only efficacy evidence is a self-reported table and screenshots (18→91) with no independent or third-party corroboration, and this static review cannot execute anything (the two provided fixtures cover only a sliver of the Docker isolation contract); the README mixes self-reported outcomes with mechanism description without clearly separating verifiable facts from inference, so all three criteria are 1.
- All isolation and security guarantees come solely from README prose; kernel implementation code was not part of the reviewed evidence — audit the actual container and credential isolation before deployment.
- Dependencies are wide-range declarations with no lockfile; supply-chain risk must be assessed independently, and the runtime requires Docker plus several self-hosted services, raising deployment cost.
- The efficacy figures (18→91) are self-reported by the author and unverified; runs consume substantial model tokens, so estimate cost before use.
- Evolved agents may carry arbitrarily mutated dependencies and code; review the final exported population before reusing it.
FAQ
How much does a run cost?
Can an agent change its own score or game the grading?
What happens if an agent crashes or the Grader goes down?
How do I get the best agents after evolution finishes?
./kadath.sh export RUN_ID. Each winner appears under .kadath/exports/RUN_ID/final-population/ as a complete runnable framework directory, and you can continue a new run from any registered genome with a fresh approval boundary.