THE WORLD'S FIRST RECURSIVE CLI
Built for Bigger Terminal Jobs.
R-CLI uses recursive AI agents to decompose complex terminal work, execute autonomously, verify results, and keep going until the task is done.
Proof bar
Built for benchmark-leading terminal performance
Designed for impressive results on Terminal Bench, with third-party validation at the center of the product story.
Section: The problem
Most AI coding tools are built for short interactions
Today's AI developer tools are good at helping with the next step:
SHORT INTERACTIONS
write a function
explain an error
suggest a command
patch a small bug
BIGGER TERMINAL JOBS
They require planning, execution, verification, recovery, and persistence across multiple steps. As tasks get longer, most tools become harder to manage. Context balloons, token usage climbs, costs rise, and reliability drops.
That is where R-CLI comes in.
Section: What R-CLI is
A new kind of command line
R-CLI is not just another AI CLI.
It is a Recursive CLI: a command line powered by recursive AI agents that can decompose large goals into smaller sub-tasks, execute them in the terminal, verify results, and continue iterating until the work is complete.
GOAL INPUT
r-cli "fix failing test suite and verify release readiness"
RECURSIVE LOOP
↳ decompose goal into sub-tasks
↳ execute in terminal
↳ verify results
↳ continue iterating
Give it a goal, not just a command.
How it works
Recursive by design
R-CLI approaches terminal work as a loop:
This recursive execution model is what makes R-CLI different. It is not optimized for one-shot answers. It is optimized for getting complex work across the finish line.
Why recursion wins
Bigger jobs require focused context
Most AI tools carry too much context forward as tasks grow. Over time, the model is forced to work with more irrelevant state, which increases token usage, raises cost, and makes actions less reliable.
R-CLI is context-efficient by design.
Its recursive architecture keeps each sub-task focused on the context it actually needs, instead of repeatedly pulling the full workflow into the model window. That means the system stays sharper over long jobs.
Why this matters:
lower token usage
lower inference cost
less context pollution
more reliable model actions
stronger performance on long, multi-step workflows
When context stays focused, the model stays effective.
Why developers will care
Built to finish what others start
R-CLI is designed for developers who need more than command suggestions.
It is built for workflows like:
Fixing a broken test suite across multiple files
R-CLI decomposes the failing test suite into individual failures, patches affected files, re-runs checks, and recurses until the full suite passes.
Implementing a feature and validating it end to end
Give R-CLI a feature goal and it will scaffold, implement, run tests, and verify the feature works across your stack before reporting completion.
Investigating and debugging complex failures
R-CLI traces errors across logs, code, and configuration, generates hypotheses, applies fixes, and verifies each fix actually resolves the issue.
Setting up infrastructure and verifying it works
From provisioning to configuration to health checks, R-CLI handles multi-step infrastructure setup and validates each component is operational.
Handling long terminal workflows without constant supervision
R-CLI manages autonomous multi-step terminal workflows, retrying on failure and continuing through the task tree without requiring you to babysit every step.
Instead of stopping after the first output, R-CLI keeps working through the problem.
With R-CLI, you get:
stronger performance on long-horizon terminal tasks
autonomous sub-task handling
retry and recovery behavior
lower token consumption
lower cost per workflow
more reliable execution over time
Alpha invite
Join the first wave
We are opening early access to developers who want to push AI tools on real terminal workflows.