With and without
Same agent. Same model. Now with a manager.
A coding agent on its own, and the same agent working under Jaah. The model is the same. What changes is everything around it: the brief, the reviews, the record and the rules.
Say it. Then leave.
| Use case | Agent alone | Agent under Jaah |
|---|---|---|
| Write the code, run the commands, edit the files | Yes | Yes |
| Hand over a task from a board and walk away | No | Yes |
| Size the work: a sketch, a task or an epic | No | Yes |
| Keep a human in the loop, or not: decide per task whether the agent asks before it decides | No | Yes |
| Talk an idea through with an advisor, who files the tasks you agree on | No | Yes |
| Attach the Jira issue on the way in, get the outcome commented back | No | Yes |
| Scheduled documentation, test, cleanup and refactor work that files its own tasks | No | Yes |
| A GitHub event, a webhook or a Slack mention files the task | No | Yes |
| Run your own playbook: the stages, the expert for each and what it hands back | No | Yes |
Stages, not a bigger prompt.
| Use case | Agent alone | Agent under Jaah |
|---|---|---|
| Split a feature into analysis, design, plan, build, finish, each with a deliverable | No | Yes |
| The last stage checks what was delivered against the original ask | No | Yes |
| The agent stops to ask you a question, with options and a recommendation | Yes | Yes |
| You answer from Slack on your phone, and the same run carries on | No | Yes |
| Whoever on the team sees the question first answers it | No | Yes |
| Hear of each question in Telegram or by email, with a link straight to it | No | Yes |
The laptop is optional.
| Use case | Agent alone | Agent under Jaah |
|---|---|---|
| Run one task on the laptop in front of you | Yes | Yes |
| Run many tasks at once, on your own machines, in your AWS account or on machines Jaah runs | No | Yes |
| Each task on its own copy of the code with its own ports | No | Yes |
| Cloud machines kept at the count you set | No | Yes |
| Credentials encrypted and handed to each run per call | No | Yes |
| Keep a project memory: what one task learns, the next one is told | No | Yes |
| Pick the agent per task or project: your own, or one from the public ACP registry | No | Yes |
| Follow a running task in a chat beside its terminal, and answer it there | No | Yes |
| Share one filesystem between agents on several machines, over NodeLink | No | Yes |
Zero “looks good to me”.
| Use case | Agent alone | Agent under Jaah |
|---|---|---|
| A code review, a security review and an acceptance check, each its own pass, and blockers fixed before it ships | No | Yes |
| A change to authentication, credentials, migrations or personal data waits for a person, or gets a security pass of its own | No | Yes |
| A guard on the machine refuses any push to main | No | Yes |
| Merges once the tests and the reviews pass | No | Yes |
| Queue changes in a merge lane that batches them and bisects a failed batch to its culprit | No | Yes |
Receipts, not vibes.
| Use case | Agent alone | Agent under Jaah |
|---|---|---|
| See evidence the task was done: each acceptance item checked, with screenshots | No | Yes |
| The session transcript, every command, and the tokens and cost by model, kept on the task | No | Yes |
| Open a task’s record a year later | No | Yes |
| Review the execution report on each task your team ran | No | Yes |
| A signed record of each task that anyone can verify | No | Yes |
| Export the signed audit trail to your own SIEM | No | Yes |
| Set data retention for transcripts, activity and task files | No | Yes |
| Publish chosen tasks to a public page anyone can read, with Live Cast | No | Yes |
Ten repositories, one standard.
| Use case | Agent alone | Agent under Jaah |
|---|---|---|
| One catalog of rules carried into every repository | No | Yes |
| The skills for each stack, the subagents and the reviewers, set up on every machine and in every repository | No | Yes |
| A compliance grid across the estate; one campaign fixes a failing rule everywhere | No | Yes |
| One board of what is running, finished and waiting, across every project | No | Yes |
| SCIM and SSO for the whole team, with MFA enforced | No | Yes |
| Run every agent under your own model accounts | Yes | Yes |
| One project across several repositories, with one primary where the checks run | No | Yes |
Who it’s for
Your roadmap shouldn’t take quarters to ship.
For anyone who delegates work to AI agents — but still owns what ships.
By company
Startups. One engineer and a fleet of agents, side by side.
Scale-ups. More hands on the backlog without more hires, and every change still reviewed.
Enterprises. Roles, SCIM and SSO, SIEM exports and a compliance grid across every repository, on the machines you choose.
Agencies and consultancies. Every client repository on one house standard, every change reported.
Software vendors. One product across many repositories in one project, each held to the same rules.
Solo builders. Describe a feature in a line. Get back a reviewed, tested change.
By role
CTOs and VPs of Engineering. The whole backlog moving, with the cost of every task on record.
Engineering managers. Hand over the tickets. Each comes back reviewed, with a report.
Platform and DevOps. Agents on the machines you choose, sharing files over NodeLink, with the access and credentials you grant.
Security and compliance. An owner, a transcript and a review on every change, with the audit trail in your own SIEM. A sensitive change gets a second, security review.
Product managers. Requirements, an advisor to think out loud with, and a clickable mockup before anything is built.
Engineers. Hand off the chores to the agent you pick. Keep the interesting work.
Finance and operations. Time, tokens and cost by model on every task, ready to check against the bill.
By situation
The backlog outgrew the team. Many tasks at once, each on its own copy of the code.
Many repositories, one standard. Your rules in every repository, checked on one grid.
Audited or regulated. Every command and every change on the record, with a named owner and a signed manifest.
Upgrades nobody gets to. Refactors and upgrades, tested before they merge.
Chores that never end. Recurring work on a schedule that files its own tasks.
Work spread across tools. Jira issues linked on the way in, questions answered from Slack, alerts in Telegram or by email.
What it can do
Code, and most of the work around it.
If it lives in a repository, or behind an API you grant, an agent can do it.
In the codebase
Code. Features, fixes, refactors and upgrades across one repository or several, delivered as a merged change.
Tests. Tests written for what has none, and the slowly slowing suite made cheaper to run.
Reviews. A code review and a security review of any change, blockers named before it ships.
Planning. Requirements and designs, a big brief run as an epic, or your own playbook.
Translation. New and changed text translated into every other language your project ships.
Documentation. READMEs, decision records and the drifting docs, kept current with the code.
DevOps. CI and deploy pipelines, and infrastructure as code.
Upkeep. Your standards in every repository, dependency updates, and Jira issues commented back.
Research and marketing
Research. Market, competitor and pricing studies, and regulation read and summarised. Every report independently reviewed.
Marketing and SEO. SEO audits, keyword and competitor gap reports, blog posts, case studies and launch briefs.
Websites and media. Marketing sites, landing pages, clickable prototypes and tutorial videos.
Documents. Policies, runbooks and how-tos, checked against your own rules and kept current.
Sales, data and operations
Sales and CRM. Prospect and account research, meeting briefs, proposals, and HubSpot records kept tidy.
Data and reporting. Reports, charts and spreadsheets with working formulas, or a dashboard as a web page.
Finance and operations. Reports from Xero and Clockify, expenses and invoices sorted, time and cost rolled up.
On a schedule. Competitor pages watched, a weekly brief in Slack, and recurring work or a webhook that files its own tasks.
Anywhere
Work from wherever you are.
Your laptop or your phone: the console goes where you go, and the work never waits for you to sit down.
See it on a phonePriced by the agent, not by the hour.
Your backlog is waiting.
The agents work on your own machines and hand back finished work, each piece with its report. Start free, then pick the plan that fits what you run.