What it actually is, how much context it really holds, how to download it, and how to point any OpenAI-shaped client at it — your own agent, Hermes, a Pi on your desk, whatever you already run.
rook is a copy of Ornith — specifically the Ornith-1.5-35B-A3B
line, released MIT on 2026-08-18. We did not train a coding model from scratch and
we are not going to pretend otherwise.
It is a mixture-of-experts: 35B parameters total, ~3B active per token. That ratio is the whole reason it is affordable to serve — you pay compute for 3B while getting the breadth of 35B. It was built for agentic coding with self-scaffolding RL, which is why it behaves well inside a dispatch→apply→verify loop instead of just emitting a file and hoping.
A correction we published against ourselves. An earlier internal note claimed the relevant Ornith model was a dense 31B built on a different architecture. That was wrong on both counts: the 31B was announced but never actually published — no repository exists — and the released Ornith models use a different base than we first wrote down. Checked against the source on 2026-08-31 and corrected. If you read a spec sheet from us, it was measured or it says it wasn't.
| Property | Value | What it means for you |
|---|---|---|
| Context window | 262,144 tokens | Roughly a 600 000-word repository in one prompt. You will run out of patience before you run out of window. |
| Active params | ~3B of 35B | MoE routing. Fast and cheap per token relative to its size. |
| Licence | MIT | Ornith upstream is MIT. No per-seat licence trap. |
The caveat that matters more than the headline: 262K is what the model will accept. It is not a promise that attention stays sharp across all of it, and it is not free — you are billed on every token you send, every turn. An agent loop that stuffs the whole repo into each of forty turns will burn your month in an afternoon.
rook is built around this. It reads a ROOK.md you
write once instead of re-deriving your project from source every turn, bounds
every file read, and ships hard budget caps (below). Treat the big window as
headroom for the one turn that needs it, not as a default.
Standalone Linux x86-64 binary. No SDK, no runtime, no install step — it is one executable.
# fetch, verify, run
curl -LO https://hawktalk.ai/rookdl/rook-linux-x64.tar.gz
curl -LO https://hawktalk.ai/rookdl/SHA256SUMS
sha256sum -c SHA256SUMS --ignore-missing
tar xzf rook-linux-x64.tar.gz
./rook doctor
Or grab the bare binary:
/rookdl/rook ·
checksums: /rookdl/SHA256SUMS
Verify before you run it. We publish the digest precisely so you do not have
to take our word for the bytes.
# the two that matter export ROOKERY_PROVIDER=hawktalk export ROOKERY_API_KEY=sk-ht-… # emailed to you when you subscribe # optional: pick the model, or split recon from work export ROOKERY_MODEL=<model-id> export ROOKERY_WORK_MODEL=<model-id> # the one that writes code export ROOKERY_RECON_MODEL=<model-id> # the cheap one that reads around rook doctor # confirms key, model, gate, git, PATH
rook also speaks openai and gemini as
providers. It is not locked to us, and --race will happily pit our
model against someone else's and let your test suite pick the winner.
export ROOKERY_MONTHLY_TOKENS=500000000 # hard monthly ceiling export ROOKERY_DAILY_TOKENS=20000000 # and a daily one export ROOKERY_BREAKER_CALLS=40 # stop a runaway turn export ROOKERY_BREAKER_TOKENS=2000000
When the breaker trips, stop means stop — no gate run, no merge proposal, the tree left exactly where the turn left it.
The API is OpenAI-shaped. Anything that can talk to OpenAI can talk to us by changing two strings — the base URL and the key. There is no SDK to adopt.
Base URL https://api.hawktalk.ai/v1 Auth Authorization: Bearer sk-ht-… Endpoints /v1/chat/completions /v1/models
export OPENAI_BASE_URL=https://api.hawktalk.ai/v1
export OPENAI_API_KEY=sk-ht-…
That is usually the entire integration. Ask for the model list
first — curl -H "Authorization: Bearer $KEY"
https://api.hawktalk.ai/v1/models — and use an id it actually returns
rather than one you assumed.
Anything with a configurable OpenAI-compatible endpoint works: set the base
URL and key in its provider config and pick a model id from
/v1/models. If it lets you separate a cheap "reading" model from an
expensive "writing" one, do that — it is the single biggest saving available on
an agentic workload, and it is why rook exposes
ROOKERY_RECON_MODEL separately.
The client side is just HTTPS, so a Raspberry Pi is a perfectly good place to run an agent against us — the model is on our silicon, not yours. Two things to get right: give it a real clock (token accounting is per calendar month, UTC), and set the budget caps above, because an unattended box is exactly where a runaway loop goes unnoticed.
The rook binary above is x86-64. On ARM, run the
client of your choice against the API directly, or build rook from source.
Every allowance is per calendar month, and it resets on the 1st, UTC. It is not a lifetime bucket.
| Tier | Rate | Tokens / month | Annual |
|---|---|---|---|
| Pro | 60 rpm | 30M | 120 rpm · 60M |
| Dev | 300 rpm | 250M | 600 rpm · 500M |
| Freedom | no limit | 1B | no limit · 2B |
Paying annually doubles the monthly limits and gives you one month free. A Freedom annual seat is two billion tokens every month, not two billion once.
Check your own numbers any time — the endpoint reports the month it is counting:
curl "https://api.hawktalk.ai/v1/models" -H "Authorization: Bearer $KEY"