# AI use cases for KADATH (i3T4AN/KADATH)

Repo: [i3T4AN/KADATH](https://github.com/i3T4AN/KADATH) | Use cases: 3 | Page: https://dedupedai.com/use-cases/i3t4an-kadath/

KADATH is a Python runtime that evolves populations of autonomous AI agents over repeated, graded epochs to optimize a goal measured by a locked benchmark.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Evolve a better agent for a measurable goal: https://dedupedai.com/use-cases/i3t4an-kadath/evolve-agent-for-measurable-goal/
- Score agent output against a locked, auditable rubric: https://dedupedai.com/use-cases/i3t4an-kadath/audit-agent-output-with-locked-rubric/
- Run a web research goal with evolved browsing agents: https://dedupedai.com/use-cases/i3t4an-kadath/delegate-web-research-to-evolved-agents/

## How to evolve a better agent for a measurable goal with KADATH

Repo: [i3T4AN/KADATH](https://github.com/i3T4AN/KADATH) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Run several epochs of competing agents on one goal and keep the leader that scores highest on the locked benchmark.

**Who it is for:** A developer who has one recurring task, such as a repeatable analysis or coding objective, and has found that a single prompt gives uneven results.

**The problem:** One prompt or one agent produces inconsistent output, and tuning it by hand is slow and hard to compare.

**The outcome:** A ranked population of agents with per-epoch scores, and a top agent whose prompt, source, and framework were refined through selection under the same benchmark.

### Steps

1. Run `./kadath.sh` in the KADATH folder and enter your OpenAI API key and model ID on first launch.
2. Choose the new run option and enter the goal, the duration of each epoch, the population size, and the number of epochs.
3. Read the approval screen, which shows the objective, metric, weighted rubric, required evidence, automatic failures, and known limitations, then approve it if it matches the goal.
4. Watch the live dashboard for epoch progress, the current leaderboard, and recent high-level activity while the run executes.
5. After the final epoch, review the leaderboard and the top agent's results, and use the exports the kernel produces for the run.

### Prompt to paste into your agent

```text
In the KADATH repository, start the runtime with ./kadath.sh and create a run for the goal <goal>. Report the best fitness and median fitness of the top five for each epoch, and confirm the approved benchmark lists the required evidence and automatic failures before the run starts.
```

### Caveat

KADATH spends a large number of model tokens across every organism, Grader, and specialist call, so cost grows with population size and epoch count.

Risk, credentials: Your OpenAI API key is saved in .kadath/config.env, and every organism, Grader, and specialist call draws on that key, so repeated epochs can run up model costs.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/i3t4an-kadath/evolve-agent-for-measurable-goal/

## How to score agent output against a locked, auditable rubric with KADATH

Repo: [i3T4AN/KADATH](https://github.com/i3T4AN/KADATH) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Have the Architect define a weighted rubric, then get evidence-backed scores that the kernel computes, not the agent.

**Who it is for:** A team lead or reviewer who needs to compare agent work on a repeatable basis and wants the scoring method fixed before any agent runs.

**The problem:** Self-reported agent scores are not trustworthy, and changing the scoring criteria mid-experiment makes results impossible to compare.

**The outcome:** A benchmark with locked hashes, per-agent evidence references, and kernel-computed scores where agent self-scores are ignored.

### Steps

1. Run `./kadath.sh` and complete first-launch setup with your OpenAI API key and model ID.
2. Enter the goal for the review task, along with epoch duration, population size, and number of epochs.
3. On the approval screen, check the weighted rubric, the required evidence sources, the anti-fraud rules, and the tie-break policy, then approve only if each one is acceptable.
4. After grading, inspect the frozen evidence for a top-ranked agent and confirm that every credited claim points to an evidence reference.
5. Keep the locked objective and hashes with the run record so the same benchmark can be reused for a later comparison.

### Prompt to paste into your agent

```text
Use the KADATH runtime in this repository to create a run for the review goal <goal>. Confirm that the approved benchmark states the weighted rubric and automatic failures, and report whether the top agent's score cites evidence references for each credited item.
```

### Caveat

The Architect may define an honest measurable proxy when the real outcome cannot be verified, so the score measures that proxy and the disclosed limitations must be read alongside it.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/i3t4an-kadath/audit-agent-output-with-locked-rubric/

## How to run a web research goal with evolved browsing agents with KADATH

Repo: [i3T4AN/KADATH](https://github.com/i3T4AN/KADATH) | Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Let an evolved population search the web through local SearXNG and rank answers by a locked benchmark.

**Who it is for:** A researcher or analyst with a question that needs current public sources, who wants several agents to compete on source quality.

**The problem:** A single research agent may miss sources or overstate findings, and there is no fixed way to compare how well different research approaches did.

**The outcome:** A ranked set of research agents whose answers are graded on evidence from public web sources, with the top agent's sources and workers recorded in its frozen evidence.

### Steps

1. Run `./kadath.sh` and enter your OpenAI API key and model ID on first launch.
2. Enter the research goal, and in the approval screen confirm that web search and direct HTTP retrieval are enabled for the run.
3. Approve the benchmark only if the required evidence asks for named public sources and the anti-fraud rules cover unsupported claims.
4. Monitor the live dashboard for worker activity and crash count while agents search and retrieve pages.
5. Open the top agent's frozen evidence and check the cited sources against the approved required evidence list.

### Prompt to paste into your agent

```text
In the KADATH repository, start the runtime with ./kadath.sh and create a run for the research goal <goal> with web search enabled. Report the top agent's fitness and list the public sources it cites, and verify that each cited source appears in its frozen evidence.
```

### Caveat

Browser access is only available when the Architect approves it for the run, so the research tools available to agents depend on the approved benchmark and runtime inventory.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/i3t4an-kadath/delegate-web-research-to-evolved-agents/