Glossary.

Agentic worker (awk)

An awk is an agentic worker: an AI agent that handles a work item the way a developer or tester does, in Slack, GitHub and Jira, with the cost of each work item metered. AwkTeams is a team of awks.

The awk is the worker. Per-ticket pricing is how its work is costed, and the approval gate is where a person decides. An awk is the second player in two-player (2P) work.

What is an awk? The full page →

Reverse SaaS (service-as-a-software)

Reverse SaaS, also written service-as-a-software, is a way of selling software-driven work in which the price is attached to the finished deliverable (a set of books closed, a lead qualified, a ticket built and tested) and AI agents do most of the work. Ordinary SaaS charges for a seat that a person logs into and operates. Here there may be no seat to count, so the buyer pays for the work that comes back.

A common caution: every task an agent completes uses model tokens and often still needs a person to review it, so both are costs of delivering the work. People who raise it expect the margins of such a business to sit between an agency's and a software company's until the agents need less supervision.

The case for selling the finished work rather than the tool is made in Julien Bek's essay Services: The New Software (Sequoia Capital, March 2026). The essay itself does not use the phrase “reverse SaaS”.

Outcome-based pricing is how such a business charges. Per-ticket pricing is the same idea applied to software delivery: the deliverable is a ticket.

Work item

A work item is one piece of software work that a team tracks and hands to someone to do: a feature, a fix, a change. Teams and tools have different names for the same thing: a ticket, an issue, a story, a task. Jira and Azure DevOps both call it a work item.

On AwkTeams a work item is what you hand to a developer or tester awk, from Jira or by asking in Slack. While it is active it counts toward your plan's limit of active work items; a paused one does not.

A ticket is one kind of work item: where this site says “ticket”, it means the same thing. Per-ticket pricing puts a price on each one, and an awk is the worker that does it.

Per-ticket pricing

Per-ticket pricing attaches the cost of AI coding work to one piece of work, the ticket or work item, so you can say what that piece cost. Per-seat pricing tells you which people hold a licence, and per-token pricing tells you how much model usage was billed. Neither says what a given feature or fix cost.

On AwkTeams the cost of each work item is metered in credits as the awks work it. Plan prices are on the pricing page.

One real example, a ticket of our own: a developer awk built it, a tester awk tested it and sent one bug back, the fix was retested and passed 24 / 24, and it was left ready for a person's approval. It was metered at 2,660 credits, about $27. People's time is not in that figure, and it is one ticket, not an average.

It is one kind of outcome-based pricing, where the outcome is a ticket that has passed its checks.

See that ticket, step by step →Read more: why a per-seat bill can't give you this number (Medium) →Read more: what a per-seat bill hides (Medium) →

Outcome-based pricing

Outcome-based pricing charges for a result instead of for access or usage: a support conversation resolved, a booking completed, a task finished. It depends on the outcome being provable, so the seller has to be able to show that it happened. That is simplest when the work produces its own evidence as it goes.

Per-ticket pricing is one instance: the outcome is a ticket, and the evidence is its test results and review. Reverse SaaS is the name for a business built on charging this way.

Two-player (2P)

Two-player, or 2P, is how work runs when an awk (agentic worker) is on it. The awk is the second player: it has a name and an identity of its own, it can be given work and spoken to, and what it does is recorded as its own. The person is the first player. The contrast is single-player: an AI tool that sits inside one person's software and acts under that person's name.

What follows from it: the record can show what the awk did and where a person said yes, and a piece of work can be assigned to the awk and costed as a piece of work. Its role sets a boundary on what it does. On an awk team each awk has a name and a distinct role, you assign it a ticket, it works with your team in the open in the Slack thread, every agent action is auditable, and each ticket's cost is metered. That is a semi-identity: to your team the awk is a named participant, while the systems it works in still see the ordinary machine authentication they already accept, so it works with the tools you have today.

The second player is an awk. The first player's turn to decide comes at the approval gate.

Generative determinism

Generative determinism is an AI agent following a workflow, or a set of instructions, over a long piece of work, even when the model behind it is not a frontier one. The model's wording and reasoning can still vary from run to run. What holds is the process: the steps it takes, the checks it has to pass and the points where a person approves.

The phrase is also used elsewhere for a model that gives the same output for the same prompt; that is not the sense here. On an awk team the workflow is the same whoever assigns the ticket. Whether the awk plans first, and whether an independent tester checks the build, are the assigner's choice. The model for each step is picked within your team's settings, and not every step needs the most powerful model. Because each ticket goes through a set process and its cost is metered, the cost of one ticket can be compared with the next. It sets the process, not the result: it reduces how much the outcome depends on who is prompting, and two runs can still differ.

An awk works this way. It is what makes per-ticket pricing comparable from one ticket to the next, and the approval gate is one of the set points.

Software factory

A software factory is a way of producing software in which the work flows through a set process and most of the building and testing is done by AI agents: a work item goes in, a tested change comes out, and the steps between are the same each time. The phrase is older than AI agents (for decades it meant a standardised, tooling-heavy way of producing software), and it is in wide use now as the name of products, of companies and of published methods. It is not ours.

Where the people are differs from one use to the next. One published method says code should be neither written nor reviewed by people, with agents checking each other. The platforms that use the name mostly keep a person approving what matters.

On AwkTeams, people manage the factory and approve what ships. Your engineers and QA set the work, step in when they choose and approve the plan and the pull request; awks build and test each work item; and every work item carries its price.

An awk is a worker in it, and the approval gate is where its managers decide. Per-ticket pricing is how its output is costed.

Running an initiative through it →

Human in the loop (approval gate)

Human in the loop means a person decides at set points while agents do the work between them. An approval gate is one of those points: the work pauses there until a person says yes.

On an awk team: by default a person is asked at two points on a code ticket: the plan before the build, and the pull request before it ships. How often you're consulted in between is a dial you set.

It is where an awk stops and waits for a person. The approval points are part of the set process: see generative determinism.

How gated actions work →