Opair
Opair is an open-source coding harness that enforces a driver/navigator model where one LLM writes code and a human reviewer approves all file-system changes before they execute. It integrates natively with GitHub, GitLab, Slack, Linear, and Atlassian, allowing agencies to embed code review discipline into client workflows without a separate dashboard. Role-based permissions are defined in JSON, tool scope is restricted to engineering-only operations, and prompts can be hot-reloaded while running. Opair is built for software development agencies and engineering teams that value shared code ownership and incremental, reviewed changes over autonomous speed.
Opair is an open-source coding harness, integrating with GitHub, GitLab, Slack and Linear. InnovaAI rates it 5.2 of 10 for agency resale.
Agency Audit
Opair is an open-source coding harness that enforces a driver/navigator model where one LLM writes code and a human reviewer approves all file-system changes before they land. It integrates with GitHub, GitLab, Slack, Linear, and Atlassian, making it a fit for software development agencies that bill retainers around code quality and shared ownership. Agencies should resell this only if their clients value incremental, reviewed code changes over speed; it's not a white-label product, so client-facing surfaces display Opair branding.
5.2/10
Depends on volume
2d 1 to 2 days
- Your clients are software development teams (not marketing or operations) that already use GitHub or GitLab and value code review discipline.
- You want to position a retainer around 'LLM-assisted development with human oversight' rather than full automation.
- Your team can self-host and manage the infrastructure, or you're willing to offer managed hosting as a premium service layer.
- Your clients expect autonomous code generation without human approval gates; Opair's entire design rejects that model.
- You need a managed SaaS offering with vendor support and SLAs; Opair is open-source only and requires self-hosting.
- Your clients work in non-engineering verticals (marketing, sales, operations); Opair restricts agent tools to engineering-only scope.
Profit Path
Estimate available after setup inputs
$1K–$3K/project
Monthly Recurring
Planning benchmark at United States price levels. Not a measured market survey.
Platform Features
Core capabilities of Opair
Driver/Navigator role separation
One LLM writes code (driver), another reviews and approves changes (navigator). This enforces pair-programming discipline and ensures humans understand every change before it commits, reducing the risk of unreviewed technical debt accumulating in client codebases.
File-write approval gates
All file-system modifications require explicit user approval before execution. Agencies can configure which file types or directories require sign-off, letting them enforce policy (e.g., no changes to production configs without review) without blocking the LLM entirely.
Role-based permissions via JSON
Define driver and navigator capabilities using JSON configuration files. Agencies can restrict which tools each role can invoke (e.g., navigator can comment on diffs but cannot execute shell commands), reducing surface area for unintended changes.
GitHub and GitLab native integration
Opair reads and writes directly to GitHub or GitLab repositories, posting navigator comments on pull requests and syncing role definitions from repo config. Clients see all LLM activity in their existing version-control workflow without a separate dashboard.
Hot-reload prompt changes
Update driver and navigator system prompts while the harness is running, without restarting. Agencies can iterate on agent behavior in real time and test prompt refinements against live client projects.
Multi-LLM provider support
Works with OpenAI, Anthropic, local models via llama.cpp, and other LLM providers. Agencies can swap providers or run local models for cost control and data residency without re-architecting the harness.
What Makes Opair Different
Unique advantages vs similar tools in this niche
Driver/navigator model that keeps humans actively involved
vs Autonomous coding agents like Cursor or Copilot that operate with minimal human inputOpair separates roles and requires user approval for writes, promoting shared ownership.
No shell access or git commit tools
vs Other harnesses that allow agents to run arbitrary commands and commit codeOpair restricts tools to engineering-specific ones, preventing the agent from making unapproved changes.
Editable prompts that hot-reload
vs Fixed prompts in other toolsUsers can customize prompts to their workflow and see changes immediately.
Latest Updates
Recent releases and improvements for Opair
0.11.0 - Security fixes, new MCP linear integration, and new tools
NewSecurity fix denying exec permissions on runner tools. Added MCP linear integration and lots of new tools. Bug fixes for deploy, ignored file tools, and release argument.
0.10.0 - Security fix and MCP Slack integration
NewSecurity fix preventing project tools from reading ignored files. Added MCP Slack integration.
0.9.0 - Security fixes and MCP Cloudflare integration
NewSecurity fixes for session transcript permissions and disabling cloudflare-docs by default. Added MCP Cloudflare integration. Bug fix for collapsing multiple spaces in user input.
0.8.0 - New go get tool
NewAdded tools: go get. Multiple bug fixes for CI and www.
0.7.0 - MCP GitLab integration and project-ignore permission
NewAdded MCP GitLab integration and project-ignore permission for tools. Bug fixes for git root path detection, findInProject, conversation entries, and newline handling.
Value Equation
Outcome-likelihood-time-effort assessment for Opair
Value math requires real pricing
The Value Equation (dream outcome × likelihood ÷ time × effort) feeds directly into ROI math. Opair has no published pricing, so we hold this section until real numbers are available.
Contact OpairPricing
Platform cost for Opair
Custom pricing
Opair uses custom/enterprise pricing: rates aren't published publicly. Contact their team directly for a quote.
Contact OpairReality Check
Opair is open-source with no published SaaS tier or managed hosting option, so agencies must self-host and manage infrastructure. The driver/navigator model requires active human review for every file write, which slows deployment velocity compared to autonomous agents and may not suit clients prioritizing rapid iteration.
Moderate effort: standard configuration with some customization needed
How This Accelerates White-Label Services
Who It's For
- ✓software-development-agencies
- ✓engineering-teams-prioritizing-code-quality
- ✓teams-that-value-shared-code-ownership
Acceleration Steps
- 1Create your account and complete setup wizard
- 2Configure separate driver and navigator roles for llm-assisted coding
- 3Connect GitHub
- 4Launch your first client project
Academy for Opair
Work through it in order: the course for this service first, then the modules behind it.
Course for this service
Opair Agency Implementation, Delivering Reviewed AI Code to Clients
Learn how to set up Opair's driver/navigator model in client projects, configure role-based permissions via JSON, and build a repeatable delivery workflow that keeps humans in control of every code change. This course teaches agencies how to productize AI-assisted development while maintaining code quality and client trust through enforced review gates.
Open the courseNo Academy modules are published for this service yet. Browse the full Academy
Core concepts
The mental model you need to price and scope the work.
- Scaffold Versus Steward SplitConcept
AI code tools compress the cost of producing a first working version, but they do not compress the cost of owning it. The Scaffold Versus Steward Split separates two jobs agencies have historically billed as one: scaffolding (generating a full-stack app, wiring auth and payments, standing up a prototype) and stewardship (architecture decisions, review, and keeping consumer code in sync when contracts change). Scaffolding is where the speed advantage lives. Stewardship is where retainer value and liability live. Verdent illustrates the first half, turning a plain-English description into a working product with authentication, payments, and an admin dashboard. Ripple illustrates the second, detecting a breaking API change and opening pull requests across every affected repository. Agencies that price both halves at the same rate give away the margin on scaffolding and undercharge for stewardship. Split the two in your statements of work, and staff them differently.
- Agent Output Liability LineConcept
The Agent Output Liability Line is the boundary between code an agency can ship under its own name and code that still needs a human signature. Agentic tools now generate full-stack applications from prompts and auto-fix breaking API changes across repositories, which moves the liability question from 'did we write it' to 'who reviewed it.' Agencies that blur this line absorb client risk without pricing it. A practical test: if an agent opens a pull request at 2am and no human reads the diff before merge, that code sits above the line and belongs in a maintenance retainer, not a fixed-scope build. Tools like Agent Monitor and Agent Desk exist specifically to make that review boundary visible by surfacing per-file risk levels and session histories. The framework matters because delivery speed without a defined liability line converts margin into unpaid warranty work.
- Verification Debt CompoundingConcept
Verification Debt Compounding treats every unreviewed agent-generated commit as a small loan against future delivery capacity. The interest rate is set by how far the code drifts from the architecture a human would have chosen. Agencies that ship agent output straight to client repos accumulate this debt quietly, then pay it back in emergency debugging during a retainer sprint. The category description warns that over-reliance risks code quality inconsistency, and the operational evidence supports it: Agent Desk launched as an open-source macOS app specifically so teams can browse and review sessions across Claude Code, Cursor, Codex, and GitHub Copilot, which only matters if review is a scheduled step rather than an afterthought. A 10 MB in-browser model from GenClass now flags silent CSS and race-condition bugs that never throw errors, the exact class of defect that passes agent self-tests and lands in production. Budget review time as a line item, not a contingency.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- When Agent Output Ships Unreviewed, Cap the Blast Radius FirstEvaluation Rule
Set a hard blast-radius limit per agent run, then require a named human reviewer before any change merges into a client branch.
- AI Code Tools Rule: Price the Maintenance Tail Before the ScaffoldEvaluation Rule
Before committing a client retainer to AI-generated code, estimate the 12-month maintenance cost of that code and confirm the tooling or team can absorb it.
- AI Code Tools Decision: Scaffold-and-Review vs Autonomous Agent DeliveryDecision Framework
IF your delivery model bills fixed-scope builds on 4 to 8 week timelines and your senior engineers can absorb review load, THEN use AI code tools for scaffolding and maintenance while keeping architectural sign-off human. IF your margin depends on autonomous agents shipping unattended across client repos, THEN you need session-level audit tooling and a named fallback model before you take the retainer.
- The Silent Regression Trap: Why AI Code Tools Pass Review and Fail in ProductionFailure Pattern
- The Scaffold-Without-Owner Trap: Why AI Code Tools Stall After the First SprintFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Agentic Code Delivery Pilot (10-15 days)Implementation Blueprint
A fixed-scope pilot that puts AI code tools behind human architectural review on one live client codebase, so an agency can quote faster delivery without betting a retainer on unreviewed output.
- Agent Output Review Gate (QA)Operating Procedure
- Agent Session Audit and Cost Reconciliation (Retention)Operating Procedure
- Scaffold-to-Production Promotion Gate (Delivery)Operating Procedure
13 modules selected for Opair
Frequently Asked Questions
Answers about pricing, setup, implementation
Opair is a coding harness that pairs an LLM driver (writes code) with a human navigator (approves changes). It gates all file writes behind user approval, restricts agent tools to engineering-only scope, and integrates with GitHub, GitLab, Slack, Linear, and Atlassian. The design enforces shared code ownership so humans remain in control and understand every change before it lands.
Opair is open-source and free to use. There is no published SaaS pricing or managed hosting tier. Agencies must self-host the harness on their own infrastructure or offer managed hosting as a premium service.
No verified white-label program. Client-facing surfaces display the Opair brand. Agencies can self-host and customize the underlying harness, but cannot remove or replace Opair branding in the user interface or integrate it into a fully white-labeled client portal.
Yes. Opair has native integration with both GitHub and GitLab. It reads and writes to repositories, posts navigator comments on pull requests, and syncs role-based permissions from JSON files stored in the repo. Clients see all LLM activity directly in their version-control workflow.
Setup time depends on infrastructure readiness. If your agency already has a self-hosted Opair instance running, onboarding a new client typically involves creating a repository, defining role permissions in JSON, and connecting GitHub or GitLab credentials. Expect 30-60 minutes per client once the parent harness is deployed.
Opair is designed for software development agencies, engineering teams, and SaaS startups that prioritize code quality and shared ownership over speed. It fits clients who already use GitHub, GitLab, Linear, or Atlassian and want LLM-assisted development with human oversight baked in. It is not suitable for non-engineering verticals like marketing, sales operations, or customer support.