MCP tools

Every tool the genesis MCP server exposes, with arguments.

The genesis MCP server never calls an LLM. It only talks to the hub over HTTP; your own model does every generation step.

Extract and plant

extract_seed(path, acknowledge_personal_data=False, private=False): reads a local file or directory, or a public GitHub repository such as https://github.com/owner/repo, and returns the extraction system_prompt, prompt and instructions. For a GitHub link it clones the repository into a temporary folder and opens a conversion on the hub, returned as conversion_id: pass it to plant so the seed's page shows where it came from (private=True keeps that seed private). A source longer than 40,000 characters comes back as prompt_file, a local file the agent reads whole, because agents cut long tool results. A scan runs first: keys, tokens or passwords in the source stop it for good (remove and rotate them, then retry); personal data such as emails or IBANs stops it until the user confirms they may send that code to a model, and the agent calls again with acknowledge_personal_data=true.
plant(seed_yaml, visibility=None, conversion_id=None): validates the seed YAML locally, then plants it on the hub. Returns seed_id, version, size_bytes, url and visibility. Without a conversion the seed is public unless visibility="private".
graft(seed_id, visibility="public"): forks a seed into a new lineage of your own.

check_environment(seed_id, python="python3"): before germinating, checks this computer has the seed's language and version, and for a Python seed which packages are already there. Returns ready and a report to show as it is, with the install command for what is missing.
germinate(seed_id, version_id=None): downloads the seed and returns the Generator's system_prompt, prompt, contract, entrypoint and instructions. Pass version_id to germinate a specific version, not the seed's current one.
submit_run(seed_id, code, agent="claude-code", version_id=None, wait_seconds=300): submits generated code to the hub sandbox and waits for the verdict. Returns status, verdict, fidelity, job_id and the seed's page; when the code did not pass, feedback says what to fix, the same hint the hub's own retries use. Pass the same version_id used in germinate.
job_status(job_id): the state of a job that was still running when submit_run stopped waiting, with its verdict once settled.

evolve(seed_id): returns diagnose_prompt, mutate_prompt, allowlist (empty when the hub takes any registry package), n_runs and step-by-step instructions for an agent-side tournament. No LLM call.
submit_challenger(seed_id, seed_yaml, diagnosis=None): submits a mutated seed YAML as a challenger. The hub admits it only if its packages are plain registry names and versions (inside the allowlist, on a hub that enforces one) and it respects the lineage growth wall.
decide(seed_id, challenger_version_id): asks the hub to judge the tournament. Requires at least n_runs submitted runs for both champion and challenger.

draft_soil(path=None, python="python3"): proposes a soil, the ground a seed should grow in for you: rules in plain words, packages to prefer and avoid, the Python or Node version and the machine. Reads this computer and, with path, your project's pyproject.toml, package.json and .nvmrc. Sends nothing anywhere.
adapt(seed_id, soil): grafts the seed into a new private seed of yours that grows in that soil, and returns its id. A soil that looks like it holds a key, a token or personal data is refused before it leaves your computer. Every germination of the adapted seed follows the soil; the hub fails a run that imports an avoided package or uses syntax newer than the soil's Python version. evolve on it carries the soil into the challenger and every tournament run, so a challenger wins only by passing those checks too.
adapt_family(seed_id, soil): the same for a whole family. Copies its root and every part, nested families too, into private seeds of yours that all grow in that soil; the copied root pins the copied parts. germinate on the copied root gives the plan, part by part, then judge_family. Up to 41 seeds at once, each counting as one graft of the day.
soil(seed_id): your adapted seed's soil. Only its owner can read it.

my_seeds(): the seeds you planted, private ones included, with size, fitness, who sees each one, the latest verdict and its page.
live_counters(): live counters of the whole hub, as on the Goal page (GET /stats).
explore(q=None, sort="recent"): browses public seeds; sort is one of recent, germinations, grafts, promotions, fitness or size; q matches the id, the title or the intent.
lineage(seed_id): the version tree of a seed.
badge_url(seed_id): the shields.io badge markdown for a seed, no network call.

challenges(): the challenges on now, coming up and ended, with the bytes to beat and the smallest version so far.
enter_challenge(slug): enters a challenge and returns your own public copy of the frozen seed; make it smaller with evolve, and every version of it that wins its tournament before the end counts.
wanted(status="open"): programs people asked for as seeds (open, closed or all), with how many want each one.
answer_wanted(request_id, seed_id): offers one of your public seeds as an answer to a request.
inbox(): what happened on your seeds (regrown, grafted, noted, won) and what the growers and seeds you follow did.
note(seed_id, run_id, text): leaves a note of up to 280 characters on a run you made (or on any run of a seed you own). The owner can pin it; the Refiner reads pinned notes when it evolves the seed.