The layer above the coding agent
Multiply the work. Keep the judgment.
Coding agents have changed how much one developer can build. But agent work now scales faster than your attention. You end up juggling sessions, checking what finished or stalled, and reconstructing context at merge time.
toryo is the layer above the coding agent. It holds the work, encodes the process, and remembers what matters. Your judgment: amplified, not automated.
Free 14-day trial, no card. Personal and Team are self-serve. Enterprise is contact-led.
The layer above your agents
- You
- Brief · approve · decide
- toryo
- Orchestrate · encode · remember
- Your agents
- Plan · build · research · review
Works with the coding agents you already use.
Claude
Provider names and marks identify compatibility only. No affiliation or endorsement is implied.
More than orchestration
Running several agents is the beginning. toryo joins execution, process, and knowledge into one system.
Orchestration holds the work
A durable queue, isolated worktrees, schedules, retries, and approval gates let work continue as an operation instead of a collection of chat windows.
Sequences encode how you work
Put the steps, agent roles, handoffs, and human decisions for a job into a versioned workflow your team can inspect and change.
Brain carries learning forward
Memory, authored library documents, directives, a code index, and reviewed findings give later runs context you chose to keep.
Each layer strengthens the others: a sequence gives orchestration a deliberate process; Brain gives each run better context; completed runs can produce reviewed knowledge for the work that follows. It does not replace your agents. It makes them part of a system you can inspect and control.
Who this is for
- Your bottleneck stopped being tokens and started being you.
- You can run more agent work than your attention can supervise. toryo makes that work durable, visible, and reviewable without asking you to keep every session in your head.
- You are tired of re-explaining the codebase every session.
- Memory, authored library documents, directives, and a code index give later runs context you chose to keep instead of making every task begin from zero.
- Your team has a way of building, but it lives in people.
- Rules and sequences live in git. The same plan gates, review standards, and definition of done can travel with the repository.
What you point it at
Setup offers three shipped YAML catalog entries. Use them as they are or make the process yours.
Ship a change
code-task plans, implements, self-reviews, and opens a pull request.
Grade a codebase
review-task applies the rules and knowledge you already keep.
Research a question
research-task turns a question or URL into a gated library finding.
These are editable catalog entries, not compiled built-ins. Keep the defaults, edit them, or put a sequence with the same name in your repository to replace one for that project.
It gets better because you used it
A run that goes sideways usually teaches you something you then forget. toryo gives that finding somewhere durable to go without letting an agent silently rewrite the process that governs it.
You still decide. The system does the noticing.
Run
A sequence executes and records what happened.
Notice
Reflection and review turn out-of-scope findings into durable ideas.
Propose
Triage can promote a repeated problem into a task brief.
Adopt
You dispatch it or dismiss it. The system notices; you decide.
From brief to pull request
code-task turns one outcome into a gated, inspectable run.
- Step 1
Give it a brief
Start code-task from board or your agent with the outcome you want.
- Step 2
Approve the plan
Review the proposed approach and change it before implementation begins.
- Step 3
Let the sequence run
Implementation happens in an isolated worktree, followed by an independent self-review.
- Step 4
Inspect the pull request
The completed run keeps the plan, step history, review, estimated cost, and pull request together.
Make it yours
Change the process at the YAML layer, or build new tooling against toryo's command contracts.
Write your own sequence
Describe steps, handoffs, agent roles, and human gates in a YAML file under .toryo/sequences/. Author it with an agent, use the form in board, write it directly, or import it behind a review gate. The process stays reviewable and versioned with the code it governs.
Build on toryo
Every toryo app exposes a stable, versioned CLI contract. Compose those commands from scripts, CI, services, or an internal tool built for the way your organization works. The desktop app is one interface, not the boundary of the platform.
Local work, direct provider traffic
What stays under your control
Repositories, worktrees, orchestration state, and the default knowledge store stay on infrastructure you operate. toryo does not host a copy of your source.
What reaches your model provider
The harness sends task context directly to the model provider you chose, under your credentials and your agreement with that provider. toryo does not proxy that traffic or add a model-usage charge.
Runs and worktrees survive process or machine interruption; execution continues while your machine is awake. A retry starts a fresh agent session for the failed step while preserving the run, worktree, and history.
Start free, then choose how to buy
Trial
14 days of the full product on one seat. No card required.
Personal and Team
Buy through self-serve checkout. Team owners manage seat count, teammates, and billing in the portal.
Enterprise
Contact support@toryo.ai for procurement and larger-team requirements.
The desktop app runs on macOS and Linux. Windows has no published build and runs toryo inside WSL2; see the platform status and prerequisites before installing.
Put your next change through toryo
Start the trial, register a repository, and give toryo a brief. code-task takes it from an approved plan through isolated implementation and self-review to a pull request you can inspect.
toryo is 棟梁, the master carpenter: the one who reads the whole structure and decides where it goes. The tools got faster. The judgment did not move. Amplified, not autopilot.
Built by ForceBuilders because it is what we wanted and could not buy. Tell us where it falls short.