Skip to content

Harness-agnostic agent delivery control

Let agents build.
Make delivery prove itself.

Otta gives Claude Code and Codex a disciplined path from issue to verified release—with specialist review stages and Pulse-enforced GitHub evidence.

See how it works Book a walkthrough
Otta delivery ledger

active delivery

PR #184 · authentication regression

Merge blocked
  1. 01 builder Regression test added and implementation submitted
  2. 02 reviewer Acceptance evidence matches 4 of 5 criteria
  3. 03 qa Session expiry path fails in the real browser
  4. 04 pulse gate_verdict: fail · merge remains blocked
  5. 05 next Return the exact failure to the builder

Delivery surfaces

01 Native workflows

Claude Code + Codex

Use deterministic Otta commands or skills without moving code into another editor.

02 Specialist stages

Builder → DevOps

Builder, reviewer, QA, and DevOps own different evidence and cannot collapse into self-approval.

03 GitHub spine

Pulse enforcement

Lifecycle events and gate verdicts keep acceptance, merge, release, and deploy state inspectable.

04 Reviewable learning

Explicit LEARN receipts

Promote durable lessons deliberately instead of silently rewriting the rules after a failure.

Live from Otta Pulse — check it yourself

1,750
merged PRs
all time
960
releases
auto-tagged
8 min
median PR cycle
open → merged
2,650
gate verdicts
enforced at merge
560
issues shipped
idea → production
65
repos watched
live

Let agents move fast. Make the evidence keep up.

Otta is the delivery control plane around Claude Code and Codex. Native workflows guide the work from a real issue through test-first implementation and specialist review; Pulse carries the evidence into GitHub and keeps merged, released, deployed, and verified states honest.

The pipeline

Intent in. Verified release out.

Five delivery stages keep the issue, implementation, independent review, GitHub evidence, and release verification connected without pretending they are one agent action.

  1. 01

    Define

    Turn intent into a testable delivery contract.

    Start from a real issue with falsifiable acceptance criteria, explicit scope, and a verification plan the whole delivery loop can carry forward.

    The builder and reviewer work from the same acceptance contract.
  2. 02

    Build

    Run Otta inside the coding harness you already use.

    Native Claude Code commands and Codex skills guide test-first implementation in an isolated branch or worktree without forcing a separate coding environment.

    A failing check comes before the smallest implementation that passes it.
  3. 03

    Specialist review

    Four roles examine the change from different angles.

    The delivery path moves through builder → reviewer → qa → devops. Each specialist produces evidence for its own concern instead of letting the author self-approve.

    Implementation, specification, user experience, and release readiness stay distinct.
  4. 04

    Enforce

    Pulse carries lifecycle evidence into GitHub.

    Otta Pulse reconstructs the issue-to-PR lifecycle from GitHub events and reports merge-gate verdicts, so repository policy does not depend on a prompt being remembered.

    Acceptance, test, review, and visual evidence can block a premature merge.
  5. 05

    Verify & learn

    Close the loop with release evidence and reviewed lessons.

    Release tags and deployment checks complete the delivery record. High-signal lessons can be promoted through explicit LEARN receipts instead of silently rewriting project rules.

    Shipped, deployed, and verified remain separate, inspectable states.

Why it’s different

Control that travels with the work.

Harness-native delivery

Use the Otta plugin in Claude Code or the Otta skills in Codex. The workflow lives where the agent already works instead of moving your code into a proprietary cockpit.

GitHub-enforced evidence

Pulse turns acceptance criteria, tests, reviews, visual proof, and lifecycle events into repository-level verdicts that an implementation agent cannot approve for itself.

Specialist separation

Builder, reviewer, QA, and DevOps are four specialist stages with different responsibilities. A green typecheck cannot masquerade as product or release verification.

Traceable lifecycle

Issue, branch, pull request, release, and deploy events stay linked. Pulse exposes what merged and shipped without asking a harness to remember the history.

Evidence before confidence

Otta asks for the smallest failing test, real browser proof for UI work, and explicit deploy evidence. Completion is a demonstrated state, not an agent's closing sentence.

Reviewable learning

Optional telemetry and LEARN receipts surface reusable lessons for review. They do not silently mutate the rules or pretend the separate autonomous-engine roadmap is already shipped.

Evidence spine

A delivery record that outlives the agent run.

Prompts end. GitHub events, acceptance evidence, release tags, and reviewed learning receipts remain inspectable for the next person or agent.

Acceptance record

Issue → branch → pull request

A fenced acceptance block carries the same testable intent from the issue into implementation, review, and the final pull request evidence.

Pulse ledger

GitHub lifecycle reconstruction

GitHub events connect issues, verdicts, merged pull requests, version tags, and deployments so the delivery state remains inspectable across agent runs.

LEARN receipt

Reviewed improvement signal

When a failure reveals a durable pattern, Otta can package the lesson for explicit review and promotion into repository knowledge or a deterministic guard.

Head to head

A different bet than the big agent platforms.

Generic agent platforms replace your coding environment. Otta keeps Claude Code or Codex in the builder seat and makes delivery evidence portable.

Focus
Otta: Delivery control and evidence around the coding agents your team already uses
Them: A replacement coding environment optimized for autonomous task execution
Quality gates
Otta: Acceptance, regression, review, visual, and release evidence enforced through the repository workflow
Them: Checks vary by platform and often remain inside the agent run
Review model
Otta: Builder → reviewer → qa → devops as distinct specialist stages
Them: The same agent loop may build, judge, and declare completion
Integration
Otta: Native Claude Code plugin, Codex skills, and Pulse GitHub enforcement
Them: Siloed web UI or proprietary desktop workspaces that force workflow migration
Target audience
Otta: Teams, small teams, founders, and builders who need delivery discipline
Them: Enterprise teams focused on ticket-to-code volume rather than quality gates
Completion evidence
Otta: Merged, released, deployed, and verified remain separate lifecycle states
Them: Task completion is commonly reported at code or pull-request creation

Comparison reflects publicly documented positioning and independent reviews of enterprise agent platforms; capabilities change over time.

Start where your agent works

One delivery loop. Two native paths.

Install the Otta workflow in Claude Code or Codex, then connect Pulse when you want GitHub lifecycle evidence and repository-level gate verdicts.

Path 01

Claude Code

slash commands

Add the marketplace, install Otta for your user, then initialize the repository.

  1. 01 /plugin marketplace add otta-build/plugin
  2. 02 /plugin install --scope user otta@otta
  3. 03 /otta:setup

Fully restart Claude Code after installation. If the commands are still missing, open /plugin and enable otta.

Path 02

Codex

native skills

Install Otta from Codex's Plugins surface, then run the setup skill in your repository.

  1. 01 Install Otta from the Codex Plugins surface
  2. 02 $otta-setup

Codex uses $otta-* skills. It does not use Claude Code's /otta:* commands.

Add Pulse when you need enforcement. The GitHub App records lifecycle evidence and gate verdicts outside the coding harness. View live Pulse →

Pricing Plans

Open workflow today. Managed evidence as you grow.

The Apache-licensed plugin is available now. Paid tiers reflect the early-access roadmap; request access to confirm current availability and fit.

01

Free

Free

The open delivery discipline for individual builders using Claude Code or Codex.

Get access
  • Native Claude Code commands and Codex skills
  • Issue-linked acceptance criteria and pull-request evidence
  • Test-first build workflow and local pre-push gate
  • Builder, reviewer, QA, and DevOps specialist stages
  • Optional hosted or self-hosted Pulse integration
  • Community support
Popular
02

Plus

$20 /mo

Early access to managed delivery evidence and guided setup for independent builders.

Get access

Everything in Free, and:

  • Managed Pulse onboarding
  • Extended issue, pull-request, release, and deploy history
  • Opt-in agent telemetry setup
  • Priority onboarding and feedback channel
03

Pro

$100 /mo

Early access for consultants and power users coordinating evidence across more repositories.

Get access

Everything in Plus, and:

  • Multi-repository Pulse portfolio
  • Extended lifecycle and gate-verdict history
  • Guided release and deployment-verification setup
  • Dedicated onboarding support
  • Early access to new features
04

Teams

Contact

The early-access roadmap for engineering leads who need shared policy, evidence, and delivery accountability.

Book a call
  • Shared repository onboarding and policy templates
  • Team lifecycle and merge-gate evidence
  • Dedicated onboarding and support
  • Managed Pulse deployment options
  • Reviewable LEARN-policy rollout
  • Custom governance and retention planning

Early access

Get access to Otta

Bring disciplined acceptance, specialist review, visual proof, and Pulse evidence to the coding agents your team already uses.

Keep the speed. Make completion demonstrable.

Request early access, or book a walkthrough to see the specialist stages, Pulse gates, and lifecycle evidence in action.

Get access Book a walkthrough