Works in Slack, GitHub and Jira
Stand up a software factory for your next initiative.
Your engineers and QA manage it. Awks build and test.
Awks (agentic workers) are AI developers and testers. There is a price on every work item, not on every seat, so you can see what the initiative is costing.
- A work item goes on the line. Set by one of your engineers, in Jira or by asking in Slack.
- The developer awk builds it. It asks its questions in Slack first; your engineers step in when they choose.
- The tester awk tests it. One case fails. 20 of 21. It goes back with steps to reproduce.
- Back down the line to the developer awk. Same work item, same thread.
- The developer awk fixes it. Second time round.
- Re-tested. 24 / 24. Ready for a person to approve.
- It comes off the line with its price. $27. Metered as the work ran. Your approval is the gate.
- The prices add up to what the initiative is costing. 13 of 20 work items so far. (Illustrative.)
The choice
A new initiative lands. Who builds it?
Reassign your team
Your own people build it, alongside or instead of their current work.
Hire or contract
People you hire or contract build it.
Bring in an agency
Another company builds it and hands it over.
Stand up a factory
Your engineers and QA manage it. Awks build and test each work item, a person approves what ships, and every work item carries its price.
Four ways to staff the same work. Not a comparison of cost or speed.
One real work item.
Start to finish.
DS-6 is a real Jira ticket on a Java backend. The developer awk picked it up in Slack, asked a person when something was unclear, built it and handed it over. The tester awk tested it, sent findings back, and re-checked the fixes. A preview link went into the thread for people to try.
- 01You· in Jira
- 02Developer awk· in Slack
- 03Tester awk1 bug found
- 03Tester awk24 of 24 pass
- 04You· preview link
- 05The receipt
Real screens from one run · click any to open it
The steps a work item goes through
From work item to done.
What always happens, and the two steps that depend on the work item. Independent QA is there when you ask for it; without it, the change comes to you after the AI developer's own tests and code review.
- Work item
You write it and assign it, the way you would for any developer: in Jira, or by asking in Slack.
- Picked up
The developer awk opens a Slack thread on the work item.
- Requirements checked
It asks whoever wrote it when something is unclear.
- Built and tested
It writes the code, runs the project’s own tests, checks the acceptance criteria and puts the change through a code review.
- Pull requestWhen the work item has a repo
Opening a pull request waits for your approval, unless a person on your team in the thread has chosen to approve them all.
- Independent QAOn request
A separate tester awk checks it against what was asked and sends it back if it finds issues.
- Ready for you
You get the change, its evidence and what it cost. A person decides what merges.
Backlog in.
Priced work out.
An initiative is a backlog of work items. Your engineers and QA run it through the factory with the tools they already use: a backlog, Slack and pull requests. Whoever on your team assigns a work item, the awk follows the same workflow, picks the model for each step within your team's settings, and manages its own context.
Break the initiative into work items the way you would for any team, then assign them in Jira or ask in Slack. Your plan sets how many are active at once. Setup is a single Slack install plus about fifteen minutes connecting your repos, and Jira if you use it.
The developer awk picks each work item up in a Slack thread, checks the requirements with whoever wrote it, then writes the code, runs the tests and puts it through a code review. Ask for independent QA and the tester awk checks it does what was asked, and sends it back if it doesn't. Your engineers and QA lead: they shape the plan with the awk and step in whenever they choose.
Each work item comes back with its evidence, a preview link to try it where there is an app to run, and what it cost. You approve what matters: a person decides whether it merges. The console adds up an initiative’s work items, so you can see what it has cost so far.
For engineers and QA
Engineers and QA become software factory managers
The same conversation, with the workflow built in.
- You assign the work item and answer the awk's questions.
- Design it together: by default the awk posts a plan, reworks it with you, and builds once you approve it.
- By default, you approve the pull request before it merges.
- Step in whenever you want: ask where it's up to, change the requirement, ask it to check something. Say stop in the thread and it stops.
- If you test, test with it: add to the awk's test cases, ask for a re-run, and take the platforms only a person can access, such as a real device.
- The price is on the work item, not on you.
One initiative. 20 work items. Your team manages the factory.
Illustrative: an initiative of 20 work items on the Starter plan, 5 active at once. Awks build and test. Your engineers lead and co-architect. Your testers lead and co-test. Together, your team approves what ships and accepts it in UAT.
Per-team pricing.
Scale as you grow.
Every plan includes always-on awk teams with GitHub App and Jira integration, frontier and near-frontier LLMs (AI usage billed in credits at $0.01 each), and per-tenant isolation. Plans scale by active work items and team count.
Credits are consumed as your awks do work. A typical small work item consumes 1,000–1,500 credits; a typical large one (such as a codebase refactor) runs 5,000–10,000 credits, depending on complexity. You'll see real-time consumption on your dashboard, and your console's analytics break it down by session and by ticket, at $0.01 per credit.
Price one of my work items →Credit pricing reflects underlying AI provider costs and operational overhead. Rates may be adjusted as we evolve the service. Annual contract customers are protected from mid-term rate changes.
Safe to say yes.
Your awks read your code, write commits and move your work items along, so the controls are built in. By default a person is asked at two points on a work item that changes code: the plan before the build, and the pull request before it ships. How often you're consulted in between is a dial you set. Merging a pull request, pushing to main and force-pushing always wait for a person's approval, wherever the dial sits. Opening a pull request and posting outside your team wait for approval too, unless a person on your team in that thread has chosen to approve all of that kind; routine moves of the assigned work item through your workflow happen automatically, and every agent action is auditable.
Strong logical isolation per tenant. Each customer gets a separate database, credentials protected by per-tenant encryption keys (no key shared across customers), and separate per-team workloads, credentials, and audit trails. Every agent runs inside an OS-level sandbox with deny-by-default network egress, and a hard cross-tenant boundary keeps each customer's data, queries, and credentials inside their own tenant. The boundary is architectural, not a policy check — no prompt, tool call, or input can carry an agent across it.
Role-scoped agents with least privilege. Read-only roles (e.g. reporting/triage agents) are technically restricted from writing. Actions that are irreversible or reach beyond your team need explicit human approval. Merging a PR, pushing to main and force-pushing are approved one at a time, every time. Opening a PR and posting externally pause for approval too, unless a person in that thread has chosen to approve all of that kind. Routine bookkeeping on the assigned work item, like moving it through your workflow, happens automatically. Write access is scoped to the specific repositories you authorise.
Every agent action is auditable. Git activity, Jira changes, work item lifecycle, team administration, credential management — all logged with the context of the agent's task. Timestamped, team-scoped, exportable to CSV. Retention by plan, from 30 days up to 10 years.
Our view
Where this is going
Delivery work is moving up a level. Engineers and QA become the managers of a software factory: they decide what gets built and whether it ships; awks build and test it. A person approves what ships, and you choose how much you're consulted along the way.
See a team
ship real work.
This week.
Thirty minutes. Pick a work item from your backlog. We'll spin up a team inside your Slack and start it on that work item while we talk. If the result holds up, you keep the pull request.