Kanaeru Software Factory
Bring the vision. Kanaeru delivers the outcome.
Ship with agents. Stay in control of the outcome.
Share your vision in plain language. Kanaeru turns it into a defined outcome and a plan you can approve, coordinates the coding agents and machines that execute it, and delivers a working change with review, tests, and evidence attached. Already use coding agents? Keep them. Kanaeru adds the production system around them.
For individuals and teams at every experience level — from non-technical domain experts and first-time builders to experienced engineers.
Factory clock
Launches 10 September 2026 at 00:00 JST
GitHub — yours, or a new one we create with you in onboarding. Plus the product context and constraints Kanaeru uses to define the outcome.
The agent accounts you already pay for, on supported runtimes. You sign them in from the Kanaeru workspace — no terminal, no config files on the machine.
In the free closed beta your code runs on a cloud machine we assign and set up, plugins already installed. Nothing to install on your own computer.
Not a replacement IDE and not another coding model. The system around the agents you keep.
Product intro
From a new vision to the next outcome.
One continuous loop, on whichever agent harness and machine you pick: describe a vision, get back outcomes and a plan you can read, see the whole system drawn before a line of code, approve what ships, then follow execution down to the diff and the evidence behind every claim.
Coding agents can build. The hard part is getting the whole outcome right.
Whether you write code or not, shipping real software spans requirements, decisions, implementation, testing, and review. In a chat-only workflow, those pieces drift apart as soon as the work crosses sessions, agents, and machines.
- Intent drifts
- The prompt in session five no longer matches the requirement from day one, and nothing flags the gap.
- Handoffs fragment
- The plan sits in one chat, the code in three branches, the review in GitHub. No one line connects them.
- Verification comes last
- You find out what the agents actually built when you read the diff. Sometimes later than that.
- Context gets rebuilt
- Every new session starts by re-explaining decisions that were already made and agreed.
One outcome, end to end
What a run actually looks like.
One vision, turned into a defined outcome and followed through to a review-ready delivery. The full six-stage line is drawn below; the film in the hero shows the real product running the same loop.
- You
Share the vision and constraints
"Let users sign in with Google. Email sign-in stays. Existing accounts with the same address get linked, not duplicated."
Kanaeru turns this vision into a defined outcome with success conditions, not a prompt that scrolls away.
- Agents propose and review · you approve
Get a plan you can read
- OAuth flow and callback route
- Account linking for existing email users
- Session handling, tests, and docs
Reviewer agents attack the plan first; tasks, dependencies, and acceptance criteria are written down before any code is.
- Agents
Execution runs in parallel
- task/oauth-callback · done, checks green
- task/account-linking · failing test caught, fixed, re-verified
- task/session-tests · done, screenshots captured
Tasks run in parallel. On supported configurations, failures are retried or rerouted and you are pulled in only for decisions.
- You
Review the delivery
The diff, the passing checks, the screenshots, and the link back to the requirement it serves.
You decide what merges. Nothing ships without you.
An illustrative example. The film in the hero shows the product itself, end to end.
The Buildline
Six stages. You appear at three.
Every outcome moves down the same line. Agents run the line: they carry context between stages, coordinate each other, and collect the proof. You set the direction, approve the reviewed plan, and decide what merges. On supported configurations, everything between those moments is automated.
Vision
Your vision, in your words
Agents map it against the repo and surface what is unclear
A defined outcome and written direction you can read in one sittingYou confirm the direction
Plan
The confirmed direction
Agents break it into tasks with dependencies and acceptance criteria
A plan you can read and editApproval comes with the next stage, Review
Review
The plan, before any code
Reviewer agents attack it for gaps, risks, and drift
Findings resolved or flagged, in writingYou approve the plan and authorize execution
Execute
Approved tasks
Agents build in parallel; supported configurations retry failures rather than losing them
Diffs, passing checks, and screenshotsYou step in only when a task asks
Deliver
The finished work
Changes are assembled into pull requests with their proof attached
PRs with tests, diffs, and screenshotsYou decide what merges
Learn
What shipped and what stalled
The run is distilled into what to keep and what to change
Learnings that load into the next outcomeNothing for you here. The system remembers
Above the model. Around the work.
A coding agent can finish a task. Kanaeru keeps the whole production system coherent while tasks, sessions, agents, and machines change. The agents are the ones you already run; what changes is the system around them.
- Your coding agents
- Write code, inspect the repository, run tools, and finish focused pieces of work.
- Kanaeru Software Factory
- Carries the requirement, plan, and prior decisions across the run. Enforces review and verification on supported runtime configurations. Recovers failed tasks where the configuration allows. Assembles the pull requests and their evidence.
- You, or your team
- Approves direction, handles real exceptions, reviews the result, and keeps the final shipping decision.
Under the hood at release: 88 specialized agents, 46 workflow skills, and 167 registered tools across 33 families. They exist so the middle layer above can do its job. The system is the product; the inventory is not.
The practical part.
What using Kanaeru actually involves. No reading between the lines required.
- Who it is for
- Individuals and teams at every level: founders, product people, operators, designers, first-time builders, and experienced engineers. You bring the vision and domain knowledge. No engineering background is required.
- What it is
- A workspace you talk to in plain language, plus an agent manager that runs on the machine behind it and drives coding agents against your repositories. It makes the planning, implementation, review, and verification discipline you expect from senior engineering accessible through one workflow.
- What you bring
- Your vision, domain knowledge, constraints, and the decisions only you can make. Kanaeru turns them into a defined outcome with success conditions. Nothing has to be connected to join: in onboarding we set up the Git repository with you — including creating one if you don’t have it — and you sign in to your own agent accounts, such as Claude Code, Codex, or GitHub Copilot CLI, from the Kanaeru workspace. It is a screen in the UI, not a machine to configure.
- Where your code runs
- In the free closed beta, on a cloud machine we assign you. It arrives with the required plugins installed, so there is nothing to set up on your own computer and no local environment to keep working. Running on your own workstation comes after the beta. The workspace keeps the coordination record: outcomes, plans, and evidence.
- What the beta involves
- It is closed and onboarded in small batches, with close support at the start. Taking part is free while the beta runs, and pricing is not announced yet.
Bring the vision. We will deliver the outcome.
We onboard individuals and teams in small batches and stay close while you start. Bring the vision; we hand you a ready cloud machine, help connect the repository and agent accounts, and run it through to an evidence-backed outcome.