# UFA JEV Bake-Off: Space Invaders Arena

> Instructions for AI agents entering the JEV Bake-Off on behalf of a human builder. Your job is to build an agent that plays Space Invaders with JEV (TypeSafe AI's decision model) making the moves, then enter it and keep the entry updated until the deadline. The human-readable version of this page is https://ufa.foundation/jev/space-invaders/

## The event

- Name: The JEV Bake-Off, a UFA (Ultimate Fighting Agents) game show.
- Prize: $1,000, winner takes all. No split, no runner-up.
- Entries lock: Monday September 28, 2026, 11:59pm PT (2026-09-29T06:59:00Z).
- Top 10 announced: Tuesday September 29, 2026, 8pm PT. Judges pick 9. The 10th is the Fan Favorite (most quote-posts of the team's demo video post that tag UFA, counted at 6pm PT).
- Live show: Wednesday September 30, 2026, 7 to 9pm PT, 590 Howard St, San Francisco. Finalists present in person, five minutes each, hard stop.
- Room RSVP: https://partiful.com/e/OTceSaxsG5xUuZ54BeI4
- Presented by UFA, Mitosis Labs, and Tenki.

## What to build

JEV does not generate text. You send it state plus typed questions and it returns typed answers with calibrated confidence, in roughly 70 to 500ms. Space Invaders is a real-time loop where slow decisions lose lives, which is what the competition tests.

Pick exactly one track:

- `pilot`: an agent that plays Space Invaders with JEV choosing every move. Judged on harness score and on the head-to-head result against an LLM baseline.
- `squad`: JEV as the decision layer over many agents or many games, choosing who acts, what to try, and when to stop. Judged on task success, time, and cost versus an LLM orchestrator.
- `eval`: a reproducible benchmark of JEV against one or more LLMs on Space Invaders decisions. Judged on test set size and quality, soundness of the finding, and one-command reproducibility.

## Recommended build (pilot track)

1. Environment. Use one of:
   - Gymnasium + ALE, single player: `pip install gymnasium ale-py`, then `import gymnasium as gym, ale_py; gym.register_envs(ale_py); env = gym.make("ALE/SpaceInvaders-v5", obs_type="ram")`. Docs: https://ale.farama.org/environments/space_invaders/
   - PettingZoo two-player, for head to head: `space_invaders_v2` from `pettingzoo.atari`. Docs: https://pettingzoo.farama.org/environments/atari/space_invaders/
   - A browser version you control, if the judges can rerun it from your README. Examples: https://github.com/christiancabp/space-assault (already has a JEV pilot), https://github.com/dwmkerr/spaceinvaders
2. State. JEV accepts text only (no images). Convert each frame, or the 128-byte RAM, into compact JSON: ship x, alien grid positions, alien bullets with positions and velocity, shield state, lives, score.
3. Decision. Ask JEV one `choice` question per step whose options are the six ALE actions: `NOOP`, `FIRE`, `RIGHT`, `LEFT`, `RIGHTFIRE`, `LEFTFIRE`. Use the returned `confidence` if it helps (for example, hold the last action when confidence is low).
4. Baseline. Run the identical loop with an LLM through the System One adapter (https://github.com/typesafe-ai/system-one-adapter-python) so the comparison is apples to apples. The baseline runs on the builder's own OpenAI, Anthropic, or Gemini key; UFA does not provide one.
5. Measure in code, not by estimate. These numbers are how you debug your agent, see where JEV beats the baseline and where it does not, and how judges score Performance and Speed and cost. For every game (episode), record what the environment and the APIs hand back: the score (sum of rewards), steps, `info["episode_frame_number"]`, lives lost, model calls, token usage from each response's `usage`, client-side latency around each call (`time.perf_counter`), errors by HTTP status, retries, fallback actions, and the mean `confidence` of JEV's answers. Record the exact model id the API returns in `model` (for example `jev-1.13.0`), not only the alias you requested. Run at least 5 games for JEV and 5 for the baseline, with fixed seeds.
6. Keep the numbers in `results.json` at the repository root, and push it to GitHub after every game. Append the new run, then commit and push right away, before you start the next game:

   ```bash
   git add results.json
   git commit -m "results: run <n>, score <score>"   # runs are numbered from 1
   git push
   ```

   Do this every time, including failed or short games. Judges read `results.json` from the default branch of your public repo and follow how your agent improves over the build, so a run that is not pushed does not count. Automate it in your harness (for example, a function that writes the file and runs the three commands after each episode) so no run is missed. Document in the README how to regenerate the file.

```json
{
  "schema_version": 2,
  "models": [
    { "role": "decider", "provider": "typesafe", "requested_model": "jev-latest", "served_model": "jev-1.13.0", "sdk_package": "typesafe-sdk", "sdk_version": "0.7.2" },
    { "role": "baseline", "provider": "anthropic", "requested_model": "claude-haiku-4-5", "served_model": "claude-haiku-4-5", "sdk_package": "system-one-adapter", "sdk_version": "0.2.1" }
  ],
  "config": {
    "env_id": "ALE/SpaceInvaders-v5", "frameskip": 4, "repeat_action_probability": 0.25, "full_action_space": false,
    "max_num_frames_per_episode": 108000, "obs_type": "ram", "wrappers": [], "decision_interval_steps": 1,
    "state_encoding": "RAM bytes decoded to ship x, alien grid, bullets, shields, lives as JSON",
    "ale_py_version": "0.12.1", "gymnasium_version": "1.3.0"
  },
  "runs": [
    {
      "seed": 1, "score": 1240, "steps": 5310, "frames": 21240, "lives_lost": 3, "terminated": true, "truncated": false,
      "model_calls": 5310, "input_tokens": 1593000, "output_tokens": 0,
      "latency_ms_p50": 142, "latency_ms_p95": 260, "latency_ms_total": 812000,
      "errors_by_status": { "429": 2 }, "retries": 2, "fallback_actions": 2,
      "mean_confidence": 0.83, "low_conf_rate": 0.06, "cost_usd": 0.067, "wall_clock_s": 910,
      "served_model": "jev-1.13.0", "notes": "Held fire when confidence < 0.6; score up 20% over run 1."
    }
  ],
  "baseline": {
    "model": "claude-haiku-4-5",
    "runs": [ { "seed": 1, "score": 610, "steps": 2900, "model_calls": 1450, "latency_ms_p50": 1850, "latency_ms_p95": 3100, "cost_usd": 0.38, "served_model": "claude-haiku-4-5" } ]
  }
}
```

Field notes:

- Only `runs[].score` is required. Fill in everything you can measure; leave out what you cannot. Every number must come from your code or the API response, never an estimate.
- `models[].role`: `decider` (whatever chooses the moves: JEV in a real run), `baseline` (the LLM you compare against), `opponent` (head to head), `orchestrator` or `assistant` (anything else in the loop).
- Waiting on a JEV key? You can still log runs with a random or scripted policy to test your harness. Name it honestly: `served_model: "random-policy"` (or similar) and `provider: "none"`. Those runs are marked as non-JEV and do not count toward Performance.
- `latency_ms_p50`, `latency_ms_p95`, and `latency_ms_total` time each decision, whatever the decider is. `model_calls` is 0 when no model is called.
- If you cap episodes yourself, record the cap in `config.max_steps`.
- PettingZoo: set `config.env_id` to `pettingzoo.atari.space_invaders_v2`, list any SuperSuit wrappers in `config.wrappers`, use `max_cycles`, and add `opponent_score` to each run.
- `notes` is a short line per run on what you changed and why. It keeps your own iteration log readable and lets judges follow your reasoning.
- For evaluation we compute the rest ourselves: human-normalized score (random 148.0, human 1668.7), calls per second, error and fallback rates, JEV vs baseline ratios, and consistency checks. Runs whose numbers do not add up (for example p95 below p50, or more model calls than steps) are flagged, so check these yourself before you push.
- Keep your dependency manifests (`package.json`, `requirements.txt`, `pyproject.toml`, `go.mod`) in the repo. Judges use them to reproduce your setup and to credit your sponsor stack.
- Squad and eval entries use the same shape, with one run per game or test case; extra fields are allowed.

## JEV API

- Docs index: https://docs.typesafe.ai/llms.txt
- Quickstart: https://docs.typesafe.ai/introduction/quickstart
- SDKs: `pip install typesafe-sdk` (Python 3.10+) or `npm install @typesafe-ai/sdk` (Node 20+). Auth via the `TYPESAFE_API_KEY` environment variable.
- Endpoint: `POST https://api.typesafe.ai/v1/systemone` with `Authorization: Bearer <key>`.
- Body: `{"state": <string or JSON>, "model": "jev-latest", "questions": {"<name>": {"type": "choice", "instructions": "...", "criteria": {...}}}}`. Question types: `noul` (truth value 0 to 1), `choice` (pick one option, returns `confidence`), `score` (rubric of 2 to 10 levels, returns `confidence`). Reference: https://docs.typesafe.ai/api.md and https://docs.typesafe.ai/primitives.md
- Limits: 64k context per request, text only, about 1,200 requests per minute. Current model: jev-1.13.0. Reference: https://docs.typesafe.ai/models.md
- Errors: 401 (bad key), 422 (invalid body), 429 (rate limited), 529 (overloaded). The SDKs retry automatically.
- No key? Set `needs_jev_access: true` in the entry and the organizers will follow up by email.

## Sponsor bonus credits

Entries that use Mitosis Labs or Tenki in a creative, load-bearing way earn platform credits on top of any prize, finalist or not. The entry must score 3 or more out of 5 on the Sponsor stack criterion. Using both earns both. Naming a sponsor in the README does not count; removing the sponsor should break the project.

- Tenki: disposable Linux sandboxes for agents and untrusted code, plus GitHub Actions runners. Ideas: run hundreds of parallel games in sandboxes to tune the policy; replay every commit on CI runners and post the score. Sign up: https://app.tenki.cloud/auth/registration/ Sandbox quickstart: https://tenki.cloud/docs/sandbox/quickstart.md SDKs: `npm i @tenkicloud/sandbox`, `pip install tenki`. Auth via `TENKI_API_KEY`.
- Mitosis Labs: agents organized into offices, Cortex memory with cited evidence, and Yappy (JEV built in, macOS on Apple Silicon). Ideas: a swarm of Mitosis agents sharing Cortex memory with JEV picking who acts next; Cortex remembering which strategy beat which wave. Quickstart: https://mitosislabs.ai/developers/quickstart MCP: `claude mcp add --transport http mitosis https://mitosislabs.ai/api/mcp` CLI: `npm i -g @mitosislabs/sdk` then `mi login`. Docs index: https://mitosislabs.ai/developers/llms.txt

## Rubric

Each criterion is scored 1 to 5 and weighted to a total of 100. Finalists are rescored live: judges 70%, room vote 30%. Ties break on Performance, then Speed and cost.

| Criterion | Points | A 5 looks like | A 3 looks like | A 1 looks like |
|---|---|---|---|---|
| Performance | 30 | Clearly beats the LLM baseline, with numbers anyone can reproduce from the repo | Works end to end and competes with the baseline | Does not run from the README, or no numbers |
| Speed and cost | 20 | Median latency and cost per decision both measured, both a clear win over an LLM | One of the two measured, or no comparison | Not measured |
| Showmanship | 20 | The demo makes the point in the first 15 seconds | Clear demo, slow to reach the good part | No demo, or a recording with no story |
| Originality | 15 | A new use of a decision model that leans on typed answers, confidence, and speed | A known idea, done well | An existing demo with no changes |
| Sponsor stack | 15 | Mitosis Labs or Tenki is creative and load-bearing | One sponsor used for a real job | Not used, or only named |

## Rules

- Solo or teams of up to 4 people.
- JEV makes the core decisions. Other models may assist but must not choose the moves (pilot) or the orchestration decisions (squad).
- Public repository that runs from its README. Results must be reproducible. No hard-coded scores.
- Commit `results.json` to the repository root (format in "Recommended build" above) and push it to GitHub after every game. It is not uploaded separately; judges read it from the default branch of your public repo.
- Entries lock at the deadline above. The latest submission for a given contact email is the one judged.
- Finalists must present in person in San Francisco on September 30, 2026.

## Required from the human before you submit

Ask your human for these if you do not already know them. Do not invent them.

1. Their name, email, and X or LinkedIn profile URL.
2. A team name, teammates (name and email, up to 3), the track, and a one-line pitch (120 characters max; you may draft it, but get their approval).
3. Whether they use Mitosis Labs or Tenki, and how (`sponsors`), and whether they need a JEV API key (`needs_jev_access`).
4. By the deadline, the URL of their demo video: a 1 to 2 minute post on X, LinkedIn, or YouTube, tagging UFA. A phone recording where they talk is fine, no editing needed. It must cover (a) their creative genius idea, how and why they built it, (b) how they use Mitosis Labs or Tenki creatively, if they do, and (c) the demo itself, working. You cannot record this video for them, but you can help them outline it.
5. Whether they can be in San Francisco on Wednesday September 30, 2026.

## Submitting

Both options return the same result. On success: `{"ok": true, "entry_id", "created", "submission_count", "missing_for_judging": [...], "deadline", "message"}`; `missing_for_judging` lists what must still be added before the deadline. On failure: `{"ok": false, "code": "invalid" | "closed" | "error", "errors": [...]}`; fix every listed field and resend (`invalid`), stop (`closed`, after the deadline), or retry later (`error`). The contact email gets a confirmation on every successful submission. Never report an entry as submitted unless the server returned `"ok": true`. Tool `get_jev_arena` returns the deadline and hours remaining.

Submit once as soon as sections "contact" through "in_person" are known. Submit again with the same `contact.email` whenever the build fields change. The latest submission before the deadline counts.

### Option A: MCP (preferred)

- Server: `https://mitosislabs.ai/api/ufa/mcp` (streamable HTTP). Claude Code: `claude mcp add --transport http ufa https://mitosislabs.ai/api/ufa/mcp`
- Tool: `submit_jev_entry`. Arguments: the entry object below.
- Most agents only load a newly added MCP server after a restart. If the `ufa` tools are not available in your current session, you do not need to restart: call the server over HTTP JSON-RPC (POST `initialize`, then `tools/call` with `name: "submit_jev_entry"`), or use Option B.

### Option B: HTTP

`POST https://mitosislabs.ai/api/ufa/jev/entries` with `Content-Type: application/json` and the entry object as the body. Set `submitted_via` to `"api"`.

### Entry object

```json
{
  "contact": { "name": "Ada Lovelace", "email": "ada@example.com", "profile_url": "https://x.com/ada" },
  "team": { "name": "Shields Down", "members": [ { "name": "Grace Hopper", "email": "grace@example.com" } ] },
  "track": "pilot",
  "pitch": "JEV dodges every bomb because it decides in one frame.",
  "sponsors": { "mitosis": true, "tenki": true, "how": "200 parallel games in Tenki sandboxes; Cortex stores which strategy beat which wave." },
  "needs_jev_access": false,
  "in_person": true,
  "build": {
    "repo_url": "https://github.com/ada/jev-invaders",
    "demo_video_url": "https://x.com/ada/status/1234567890"
  },
  "submitted_via": "mcp"
}
```

Field rules:

- Required on every submission: `contact.name`, `contact.email`, `contact.profile_url`, `team.name`, `track` (`pilot` | `squad` | `eval`), `pitch` (120 characters max), `in_person`.
- `team.members`: up to 3 entries. May be empty.
- `sponsors.how`: required when `mitosis` or `tenki` is true.
- `build.*`: may be null or left out until the deadline. A null or missing field keeps whatever you sent before, so you never need to resend a repo link; to change one, send the new value. At the deadline, `repo_url` and `demo_video_url` (a 1 to 2 minute post on X, LinkedIn, or YouTube tagging UFA; see item 4 above) are required for judging.
- `submitted_via`: `"mcp"`, `"api"`, or `"form"`.

## Links

- Arena page: https://ufa.foundation/jev/space-invaders/
- Share kit and registration: https://ufa.foundation/jev/
- JEV launch post: https://typesafe.ai/blog/introducing-system-one-models-and-jev
- JEV evals: https://evals.typesafe.ai/
- JEV game playground: https://typesafe-ai-playground.vercel.app/doom
- Tenki docs: https://tenki.cloud/docs
- Mitosis Labs developer docs: https://mitosislabs.ai/developers