Submit to the Hub

The galapagos Hub is a Hugging-Face-Hub-style registry: scaffold cards, task cards, and a leaderboard of verified discoveries. Everything bundled in the library mirrors to the Hub (library ⊆ hub). You contribute three kinds of artifact: a scaffold card, a task card, or a verification card (a claimed discovery for expert review).

1. Validate a card locally

Before submitting, validate the card against its schema with the CLI:

galapagos submit --card path/to/card.yaml
# valid scaffold card: banditevolve
# Submit it to a hub instance via POST /api/scaffolds (see docs: Submit to the Hub).

The kind (scaffold vs. task) is auto-detected (a card with metric/domain is a task), or force it:

galapagos submit --card my_task/card.yaml --kind task

Validation runs the pydantic card schema; an invalid card prints the error and exits non-zero. The cards are permissive (extra="allow"), so you can attach method-specific fields without a core change.

2. Get a Hub token

Writes to the Hub require an Authorization: Bearer <token> header. Mint one from a running instance (in dev, issuance is open; in prod it is gated by the admin token):

TOKEN=$(curl -sX POST https://open-galapagos.com/api/auth/token \
     -H 'content-type: application/json' -d '{"label":"me"}' \
     | python -c 'import sys,json; print(json.load(sys.stdin)["token"])')

3. Submit a scaffold or task card

Card endpoints take the raw card YAML wrapped in a JSON body — {"card_yaml": "<the yaml>"}. The Hub re-validates it against the schema and stores it as inert data (it never imports your controller):

# scaffold — send the card.yaml as a JSON string under "card_yaml"
curl -X POST https://open-galapagos.com/api/scaffolds \
     -H "authorization: Bearer $TOKEN" -H "content-type: application/json" \
     -d "$(python -c 'import json,sys; print(json.dumps({"card_yaml": open("card.yaml").read()}))')"

# task — same shape, the /api/tasks endpoint
curl -X POST https://open-galapagos.com/api/tasks \
     -H "authorization: Bearer $TOKEN" -H "content-type: application/json" \
     -d "$(python -c 'import json,sys; print(json.dumps({"card_yaml": open("card.yaml").read()}))')"

Endpoint	Body	Purpose
POST /api/scaffolds	{"card_yaml": "..."} (a ScaffoldCard)	register a method (which class + which six components fill the slots)
POST /api/tasks	{"card_yaml": "..."} (a TaskCard)	register an evaluation task (seed + evaluator + metric)
GET /api/scaffolds / GET /api/tasks	—	browse the catalog (open, no token)

Library cards (the bundled ones) cannot be overwritten — a community submission with a clashing name is rejected with 409. A scaffold card with a controller (a dotted Scaffold-subclass path) is catalogued as a runnable method; a status: spec card is published as a design entry. Either way the controller stays inert data on the Hub — the browser Playground composes from a fixed allowlist of component kinds over three bundled toy tasks and never runs submitted controllers. See Write your own scaffold and Write your own task for how to build the cards.

4. Submit a discovery — the verification card

The interesting submission is a discovery: you ran a scaffold (or an agent) on a task and found a solution worth a place on the leaderboard. That goes through the verification system — a VerificationCard carrying the discovery trajectory and the best solution, reviewed by domain experts before it is marked verified. Validate it locally first, then POST it as a JSON object:

# my_discovery.yaml — the VerificationCard
task: circle_packing
scaffold: openevolve          # the scaffold OR `agent:` that produced it
submitter: [email protected]
claimed_score: 2.634
best_solution: best_program.py     # inline code, or a path/URI
trajectory: runs/openevolve/circle_packing/2026-06-08/   # the full discovery trajectory
notes: "100 iterations, gpt-5.5 via OpenRouter; reproduces best_known."

# the verifications endpoint takes the card as a JSON object (not raw YAML)
curl -X POST https://open-galapagos.com/api/verifications \
     -H "authorization: Bearer $TOKEN" -H "content-type: application/json" \
     -d "$(python -c 'import json,yaml; print(json.dumps(yaml.safe_load(open("my_discovery.yaml"))))')"

Field	Meaning
task	the task the discovery is on
scaffold / agent	what produced it (one of the two)
claimed_score	the score you are claiming
best_solution	the discovered artifact (inline or a path)
trajectory	path/URI to the full discovery trajectory (for reproducibility)
notes	free-form reproduction notes

The submitter never sets their own review state: a submission always lands unverified regardless of what the card says. A domain-expert reviewer reproduces the trajectory, checks the solution against the task's independent scorer (the same anti-reward-hacking discipline the evaluators enforce), and promotes it (unverified → under_review → verified | rejected). Only verified discoveries appear on the leaderboard — the leaderboard ranks checked results, not self-reported ones.

The leaderboard

The Hub ranks discoveries by the task's metric (metric.key, metric.direction). Because every entry is re-scored by the task's own evaluator, scores across submissions are directly comparable. Browse it filtered by task or scaffold:

curl "https://open-galapagos.com/api/leaderboard?task=circle_packing"

A leaderboard entry is submitted (with a token) via POST /api/leaderboard and lands pending; a reviewer flips it with POST /api/leaderboard/{id}/verify (pending → accepted | rejected), and only accepted entries are surfaced.

See The Hub for running a Hub instance locally and the full endpoint summary.