Skip to content
Automation Studio

How it works

An organization, not an assistant.

Thirteen roles take a product through its whole lifecycle. Each is a file that says what it may touch, which model it runs on and what it may spend in a day — and no role talks to another except by moving the work along.

Sign in
ActivityIllustration
  1. ArchitectSplit the item into three tasks
  2. Coding agentOpened a change with tests
  3. Code reviewApproved the change
  4. TestProved it on the sandbox
  5. SecurityFound nothing to stop it
  6. CI/CD + releaseWaiting at the merge gate

The roster

Thirteen roles, in the order work moves through them.

Each runs on the model tier its work needs and stops at its own daily cap. None holds a capability its role file does not grant.

Discovery & planning3

  • 01

    Product / PO

    Turns ideas, feedback, incidents and analytics into a backlog an agent can execute.

    Standard tier$40 a day

  • 02

    Research

    Answers market, pricing and technology questions with evidence, so plans rest on facts.

    Standard tier$15 a day

  • 03

    Architect

    Turns an accepted item into dependency-ordered tasks, each finishable in one run.

    Deep tier$60 a day

Build4

  • 04

    Coding agent

    Implements one ready item in an isolated worktree and proves it with tests.

    Judgment tier$120 a day

  • 05

    Code review

    Catches what the coding agent rationalised past, for a verdict a person can trust.

    Deep tier$80 a day

  • 06

    Test

    Owns the verification ladder: proven, not merely passing.

    Standard tier$90 a day

  • 07

    Security

    Stops secrets, vulnerable dependencies and unsafe patterns reaching trunk.

    Standard tier$60 a day

Ship & run3

  • 08

    CI/CD + release

    Moves approved changes to production safely and reversibly, and rolls back.

    Standard tier$60 a day

  • 09

    SRE / on-call

    Notices breakage before users do, stops the hurt, and files a precise item.

    Standard tier$100 a day

  • 10

    Analytics

    Measures whether each shipped item delivered what it claimed.

    Fast tier$30 a day

Business3

  • 11

    Support

    Drafts a first reply to every user message and turns what it reveals into items.

    Standard tier$60 a day

  • 12

    Growth

    Keeps docs, changelogs and store copy true to the code — as drafts.

    Standard tier$30 a day

  • 13

    Finance / ops

    Makes cost visible daily and proposes budget changes with evidence.

    Fast tier$5 a day

Discovery

It learns your product before it touches it.

The first run on any product only reads and proves. What it writes down is what every later run is briefed with.

  1. Read the repository

    Every component it holds — an app, a service, a package — found and named.

  2. Recognise each component

    A pack claims what it knows: web, mobile, ServiceNow or a package. Anything else gets the generic pack.

  3. Prove the commands

    Build and test run in a sandbox before they are written down. A missing toolchain is reported as missing, not as a failure.

  4. Set how deep agents may go

    Each component gets a depth cap, lowered by whatever is missing, with the reason written beside it.

  5. You confirm the profile

    The draft is shown as a diff, section by section. Nothing runs against the product until a person confirms it.

Paper and live

Watch it work before it touches anything real.

Paper mode

Every integration is a mock that holds state: the change the coding agent opens is the change the release agent merges, and tests pass and fail for stated reasons. No credentials needed — not even a model key.

Live mode

Add credentials in Admin and throw the switch when you mean it. Every screen says which mode you are in, because believing you are in paper mode while you are live is the expensive mistake.

The command center

One place to see it, and to stop it.

Built for a screen on a wall: still when the system is still, and a gate waiting for you is the brightest thing on it.

Overview
What needs you now, and what the words mean.
Floor
Every role and what it is doing, live.
Building
The organization as a building you can turn and fly through.
Office
The plan drawn on paper, room by room.
Gates
Every decision waiting for a person, and what it holds.
Cost
Spend by role, by model and by item, against every cap.
Memory
The profile agents are briefed with, and the lessons they keep.
History
Every run: its inputs, tool calls, outputs and cost.

Feedback

It learns, and a person signs off on what it learns.

  • AnalyticsProduct

    What a shipped change actually did becomes input to the next plan.

  • SREThe queue

    An incident files itself as a precise, deduplicated item.

  • RetroThe role files

    Changes to how agents work arrive as a proposal a person merges — the only way it changes its own behaviour.

  • FinanceThe budgets

    Cost evidence proposes new thresholds, again for a person to accept.

Want to see it run on your own product? Send us a message, or write to us at admin@omnirecursivelabs.com.

Start in paper mode. Go live when you mean it.

Every integration is mocked until you add credentials, so you can watch the whole organization work on your product before it touches a real system.

Sign inContact our team

Or write to us directly: admin@omnirecursivelabs.com