The platform
What happens to a task, start to finish.
Five stages, from one sentence to production.
Agents research the market, write the requirements, design the architecture and the screens, build the product, test it and deploy it. As an epic, that runs in five stages: analysis pins down the ask, design chooses the approach, a plan splits the work into phases, build agents each ship their own change, and finish checks the whole against the sentence you started with. Rather work in your team’s own stages? Run one of your organisation’s playbooks instead. And all of it still has to pass your tests.
- Five stages: analysis, design, plan, build, finish
- Research and requirements, then screens and code
- Built, tested and deployed by agents

Done means verified.
One engineer agent builds the whole change — frontend, backend, infrastructure and tests — and checks it itself. A second, independent agent reviews it. A change is done when it is verified, not when the agent says so: its own tests, its pages checked in a browser at every screen size, a security pass, the bug reproduced before the fix, and an independent verifier’s sign-off before it merges.
- One full-stack engineer agent per change
- Tests, browser checks and a security pass
- An independent review, then sign-off

Hand over a task, or the whole backlog.
Write the task in a line or a page, and size it: a sketch for a quick mockup, a task that one agent ships as a merged change, an epic that is analysed and split into subtasks first. An agent picks it up on one of your organisation’s machines, works in its own copy of the code, runs your tests before every commit, and merges the change into your branch once the tests and the reviews pass. Jaah runs the backlog: it finds missing work, files and ranks the tasks, assigns agents, flags what is blocked, reassigns a task that failed and reports progress to you.
- A sketch, a task or an epic
- Your tests, before every commit
- A backlog Jaah files, ranks and assigns

Optional human in the loop: you say when it asks.
An optional human in the loop, task by task: run a task unattended and the agent makes every decision itself, or guided and it stops before each key decision with a few options and its recommendation, and the same run carries on from your answer, with any files you attach to it. Or start with a chat: talk the idea through with an advisor that has read your project.
- Unattended, guided, or a chat first
- Options, with a recommendation
- Your answer resumes the same run

An execution report for every task, from its expert.
Every task hands back the execution report its expert owes: a coder a merged change, a business analyst the requirements, an architect a design, a researcher a report, a prototyper a quick mockup. A build’s report says what changed, how each acceptance item was checked, with screenshots of the result, and what the code and security reviews found. Beside it the task keeps its history: who filed it, the brief and comments, each session’s transcript, every command and each merged change.
- A change, a document, a report or a mockup
- Each acceptance item checked, with screenshots
- Owner, brief, comments, transcript and commands

Start from a task already written.
The Templates gallery holds ready-made tasks, grouped by what they are for — build and fix, quality, security, maintenance, docs and release, research and planning — with the most popular first. Press Start, fill in the few blanks the template asks for, and the task is filed in your project with its brief already written; Customize opens the same brief in the new-task form first. Star the ones you use, keep your organisation’s own beside the official ones, and let an automation file its tasks from one.
- Fixes, tests, security, upkeep, docs and research
- Start, fill in the blanks, and it is filed
- Your own templates, used by automations too

Cost and tokens per task, live on the board.
The board shows cost and tokens per task as it runs, in Tokens and Cost columns that count an epic’s subtasks too. Open a task for its run time, the time the agent was actually working, the tokens it read and wrote, and what they cost.
- Tokens and Cost columns, live on the board
- Run time and agentic time
- Tokens in and out, and their cost

The whole organisation, on one page.
Owners and admins open the command center from Reports and see each project’s health — healthy, watch or at risk — with its latest builds and merges, read from GitHub, GitLab, Bitbucket or Azure DevOps. Beside it: who files the work person by person, each active agent’s record, delivery, cost, quality and what is going wrong, over a range from the last hour to the last year.
- Healthy, watch or at risk, per project
- Adoption, delivery, cost and quality
- From the last hour to the last year

Many agents, side by side, on one machine.
Every running task gets its own private copy of the code and its own ports, so agents build and test side by side on one machine. A stopped task keeps its copy, and picks up the work already in it when it starts again. How many run at once is a cap you set, per project or across the organisation.
- A private copy of the code per task
- Its own ports per task
- How many at once is your call

Your repositories are next. No statement of work.
Agents take your first sentence to a verified change, in the repository you pick. Start free, then pick the plan that fits what you build and how you ship today.