Genesis OL 0.17:
first contact with ARC-AGI
It answers only when every example agrees on a rule, and declines when they don't.
On 400 public puzzles it answered 82 times and was wrong 3.
Send it your own, and mark them yourself.
Genesis OL 0.17: the census
Measured 2026-09-22 by the code this endpoint serves. Public training halves; the evaluation set is sealed and unread.
ARC-AGI-1
79/400
solved
- wrong
- 3
- refused
- 318
- precision when answering
- 96.3%
- cost
- 6.5 ms/task
ARC-AGI-2
106/1000
solved
- wrong
- 3
- refused
- 891
- precision when answering
- 97.2%
- cost
- 7.8 ms/task
Coverage is the frontier; precision is the invariant. The percentages measure what the declared family can express, and it is small. The precision measures the method: when the corroboration bar is met, the answer is right 96.3% of the time on ARC-AGI-1 and 97.2% on ARC-AGI-2, at first contact, with zero tuning.
Cost is solve time, measured in-process: solve() only, in-process, median of 5 per-run means, on Apple M3, 8 cores, Node v22.22.0. It is not the endpoint's response time, which includes the network and is a different number.
The two benchmarks are not independent. 391 of ARC-AGI-1's 400 training tasks are also inside ARC-AGI-2's 1,000, which is why the same 3 tasks are wrong in both.
The hash you're talking to
6ab5dfa07bda8c5100618c04a3983409ab9ffb0e3679e1208dc58a23a95da283It covers the solver core, the numbers above were measured at it, and every answer carries it. It is our label for the build: the solver's source is private, so you cannot recompute it. What you can check is the answers themselves, every one, task by task, against the published record.
The solver is not the model
Kiinara Intelligence is building Genesis: a counting-based model that learns from experience, with no neural network, no gradient descent and no pretraining. Genesis did not produce the number on this page. A declared family of transformations did, under Genesis's operating law.
What the adapter does share
The operating law
Answer only when every example corroborates. Otherwise refuse.
The perceptual priors
Objecthood as 4-connected same-colour components, position, adjacency, counting. Colours are channel values, never meanings.
Corroboration as the test
A rule is accepted because every example agrees, not because a search over a learned space scored it highest.
So this demonstrates the method, not the mind. The day ARC is met by the model's own objecthood and induced transformations is the day the number means what a headline would imply. That day is not today.
Two things you might reasonably say
"This is Icecuber with a refusal rule."
Fair, and close to right. Icecuber, the hand-written program-synthesis solver that won the 2020 Kaggle competition, sits on the chart above at 17.0%, and this adapter is in the same family of approach. Two differences worth naming: ours refuses rather than guessing, which is why it is wrong 3 times in 400 instead of merely scoring; and Icecuber's 17.0% is on the harder semi-private set while our 19.8% is on the training half. Treat the gap as smaller than it looks.
"You didn't train, you hardcoded."
Also fair. A declared family encodes human knowledge directly: the knowledge went in through the keyboard rather than through gradient descent, and for a hand-declared family "no training" is close to tautological. The census concedes it already: the 19.8% measures the vocabulary, what the declared family can express. What it does not measure is whether that vocabulary was fitted to the answers. That is the part this endpoint exists to let you check.
The protocol, stated before any number
Pre-registered before first contact with the benchmark, and unchanged since.
- A transformation is believed only if it reproduces every training pair.
- Fewer than two training pairs. refuse. One witness is provisional.
- More than two corroborated proposals. refuse. We do not know which.
- At most two answers, the official pass@2.
- Each member may be applied after one structural pre-transform. Depth capped at two.
Refusal is a correct answer here, and the reason is the product. Every refusal names one of no_corroborated_rule, ambiguous or single_pair, so you can count them separately. Wrong-with-confidence is the failure that matters; "I don't know" is not one.
How it got there, including the part we threw away
One day of family growth on the public training halves. Every point is read from a run file recorded that day. The same series is served at /api/climb.
v0.12 and v0.16 were reverted. v0.12's drawing primitives matched nothing. v0.16 went a level deeper on composition and scored 20%, above the 19.8% that shipped, for roughly fifteen times the solve cost. Both are drawn. Leaving them out would make the curve look cleaner than the work was.
One day of family growth, v0.0 to v0.17, charted above. Each step added declared members and re-ran the whole set; nothing was ever tuned on a task. Precision rose as coverage did, from 93.8% at first contact to 96.3% at v0.17, which is the opposite of what usually happens when you push a score up.
Two batches bought nothing and are on the chart as hollow markers. v0.12 added global drawing primitives and matched zero tasks. v0.16 went one level deeper on composition, scored higher than what shipped, and was reverted the same day, for 0.2 of a point at roughly fifteen times the solve cost. A growth curve that hides its abandoned branches would be a nicer picture of a less honest day, so both are drawn.
Knock on the door
curl -s https://arc.kiinaraintelligence.com/api/v0.17/manifest
curl -s -X POST https://arc.kiinaraintelligence.com/api/v0.17/solve \
-H 'content-type: application/json' \
-d '{"tasks":[{"id":"mine","train":[…],"test":[{"input":[…]}]}]}'ARC's own JSON, unmodified. Send 25-50 tasks per request. The full guide, and the things you can check →
It never scores
It does not accept a claimed answer and never tells you whether you were right. The deployed bundle ships no answer key at all, so it could not score if it wanted to. Marking happens on your machine.
It never keeps your puzzles
Submitted tasks are answered and dropped, never stored, never logged. The application records method, path, status, latency and a task count. Nothing else, and no grid ever reaches a log line.
It never asks for a key
A full ARC-AGI-1 run is 8-16 requests. The open tier covers it with no key. A limit that stopped you reproducing the headline would be a strange thing for us to build.
Where this goes
This adapter is frozen. The declared family is closed, and the number on this page is not expected to move. The honest ceiling of an instrument like this one is near where it already stands, and reaching higher would take a different engine, not more members.
The work moved to the model: teaching Genesis to hold the same law over experience it gathers itself, rather than over a family we wrote by hand. When ARC is met by its own objecthood and its own induced transformations, the number will mean what a headline would imply. That is the next post, and it will be measured the same way.
What this is not
- Not verified. No third party has run these figures. Every one is self-reported, and the endpoint is how you check them yourself.
- Not the evaluation set. These are the public training halves, sealed set unread.
- Not a frontier comparison. 22 systems on ARC Prize's live ARC-AGI-1 board score 97% or more, at $0.06 to $2.11 per task: internet-trained systems for which years of ARC material are training data, measured by ARC Prize on their semi-private evaluation set. The chart above plots every one of them, live. A different experiment entirely, and not a race Genesis is running.