The fewest tokens from intent to working code.
The intended author is an LLM, not a human. Prefix notation. Single-character names. Type-verified before execution. JSON out by default. Every design decision evaluated against total token cost.
Try an example, or write your own. Open the playground ↗
from functools import reduce nums = [1, 2, 3, 4, 5] total = reduce(lambda a, b: a + b, nums, 0) print(total)
fld + [1,2,3,4,5] 0
ilo is actively evolving. Today's syntax and builtins are not yet a contract, so run it in a safe environment, not against production. Install on your machine, or hand it to an agent.
Two ways to give an agent ilo: install the Claude Code plugin, or add the skill to any agent that runs the Agent Skills standard.
Adds the marketplace once, then installs the plugin. Claude Code picks up the bundled Agent Skill automatically.
Run a one-liner: ilo 'dbl x:n>n;*x 2' 5
It prints 10.
Or edit Python live in the playground →
Learn the syntax, the builtins, and the error model. Introduction →
Every feature exists to reduce total token cost.
Operators before operands. No parentheses. No precedence ambiguity. 22% fewer tokens, 42% fewer characters vs infix.
+*a b c (a × b) + csafety
Every program is type-checked before it runs. Agents get compact error codes, not stack traces. One token, not a paragraph.
ILO-T004: expected n, got tcontrol
Flat conditionals. No nesting. No braces.
>=sp 1000 "gold"composition
Chain functions left-to-right.
x>>dbl>>incergonomics
12 tokens down to 1. Error propagation without the ceremony.
inner! x integrations Wire external APIs as typed functions. Type-checked at load time.
--tools tools.json agent server A long-lived JSON request/response loop. Agents compile, check, run, and trace without a process per call.
ilo serv http Serve an ilo function over HTTP. One command, no framework.
ilo httpd app.ilo --port 8080
Named from Toki Pona for “tool”: a constructed language that captures all of human expression in ~120 words. ilo does the same for machine programmers.
Tokens (generation, retries, errors, context loading) are the only cost we minimise. Each rule below is a constraint we accepted to lower it. If a feature spends tokens, it has to earn them.
Tokens are the only budget. Everything else is decoration.
Generation, errors, retries, and context loading all spend the same pool. Every syntax choice is benchmarked against this sum, not lines, not characters, not readability arguments imported from human languages.
lines · characters · "looks like English"
Median across 24 reference tasks vs idiomatic Python. Worst case 41%.
Closed vocabulary. No hallucinations possible.
Every callable, type, and operator is known at parse time. The agent picks from a smaller set of valid next tokens, which means fewer wrong paths and fewer retries.
dynamic dispatch · metaprogramming · open extension points
$ ilo --vocab | wc -l → 47 # sigils + keywords $ ilo --builtins | jq length → 138
A signature is a complete contract.
Every function declares its parameters, return type, and effects on one line. The agent never has to follow imports or read a header to know what something does or what it touches.
headers · cross-file type inference · implicit effects
fetch u:s>j !net # params, return, effect # all in one line
Sigils over keywords. English is not a dependency.
Operators are single characters. Type annotations are single letters. The full vocabulary fits on one page, and an agent learns it from the spec alone, no training-data exposure required.
keyword soup · word-of-the-day naming · ASCII art operators
Builtin-recall benchmark on frontier models given only the spec. No fine-tuning, no in-context examples.
The dependency graph is a first-class CLI artifact.
ilo graph returns the call graph, type graph, and caller graph as JSON. Edit one function and the agent reloads only what changed, usually 6 to 10% of the codebase.
whole-tree re-reads · file-scope context · "just grep for it"
$ ilo graph --of dbl --json → { callers: 3, types: ["n"], touches: 7% }
Every output parses. Every error is a code.
Every subcommand supports --json. Every diagnostic carries a code, a source span, and a FixSafety field telling the agent whether the auto-fix is sound. Zero screen-scraping. Zero re-prompts for structure.
pretty-printed errors · stack traces · free-form text
{ "code": "ILO-T004",
"span": [12, 18],
"got": "t",
"want": "n",
"fix": "SAFE" } Three runtimes: a bytecode VM, a Cranelift JIT, and a Cranelift AOT compiler. Faster than Python and Ruby, slower than V8 and Go. ilo optimises tokens, not nanoseconds.
Notes from building ilo, and the ideas around it.
Every subcommand speaks --json. The agent sends a request, ilo replies with structured diagnostics and fix plans, and the loop closes without screen-scraping.
"method": "check",
"program": "main>_;prnt +2 a""schemaVersion": 1,
"error": "phase": "verify",
"diagnostics": [
"code": "ILO-T004",
"message": "undefined variable 'a'",
"suggestion": "did you mean 'main'?"
]"method": "run",
"program": "main>_;prnt +2 2""schemaVersion": 1,
"ok": 4,
"ms": 0Make your AI agents more efficient.