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 scores it 5.2/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-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.
No Academy modules are published for this service yet. Browse the full Academy
Why this category matters
The commercial case before the tooling.
Core concepts
The mental model you need to price and scope the work.
- Scaffold, Don't SubstituteConcept
Scaffold, Don't Substitute is a framework for agencies adopting AI code tools: use them to generate scaffolding and handle maintenance, but never as a replacement for human architectural oversight. The strategic insight from the category description warns that over-reliance risks code quality inconsistency and vendor lock-in. For example, an agency might use Verdent to rapidly prototype a full-stack app from a natural language brief, then have senior engineers review and refactor the generated code before delivery. Similarly, Ripple can auto-fix consumer code when APIs break, but a human must verify the changes align with client contracts. This framework helps agencies capture speed advantages while protecting quality and client trust. It also aligns with recent market data showing that AI agent loops can run 100x cheaper via simulation, but accuracy tradeoffs demand human judgment for high-stakes tasks.
- Human Checkpoint RatioConcept
The Human Checkpoint Ratio is the proportion of AI-generated code that passes through human review before delivery. Agencies adopting AI code tools often see speed gains, but unchecked automation can introduce subtle bugs and architectural drift. The framework holds that the optimal ratio depends on task risk: scaffolding and boilerplate can run nearly autonomous, while core business logic and client-facing features demand human sign-off. For example, HumanLayer structures workflows with six phases, each requiring human checkpoints, ensuring alignment and early error catching. Similarly, Ripple automates API break fixes but relies on developers to review generated pull requests. Agencies should define explicit checkpoints per task type, balancing speed with quality. A 100x cost reduction in simulation-based agents, as reported by Marktechpost, suggests that high-volume, low-stakes tasks can tolerate lower ratios, freeing human oversight for critical paths.
- Maintenance Over BuildConcept
AI code tools shift agency value from greenfield builds to ongoing maintenance. Platforms like Ripple auto-fix breaking API changes across repos, while Verdent generates full-stack apps from prompts, making initial builds cheap and commoditized. The durable margin lies in keeping client systems healthy: dependency updates, security patches, and refactors. Agencies that sell maintenance retainers, not just launch fees, convert a one-off project into recurring revenue. A 100x cost reduction in agent loops, as reported in simulation research, makes automated upkeep affordable at scale. The framework: use AI for scaffolding and repairs, but anchor the commercial model on continuous care, where human oversight prevents the quality drift that pure automation introduces.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- AI Code Tools Rule: Scaffold Fast, Architect SlowEvaluation Rule
Use AI code tools for scaffolding and maintenance tasks, but keep human architectural oversight for production decisions.
- AI Code Tools Rule: When Delivery Speed Is the Bottleneck, Automate Maintenance Before Greenfield BuildsEvaluation Rule
Use AI code tools for scaffolding and maintenance automation first, and reserve human architects for greenfield design and final review.
- The Scaffolding-Only Trap: Why AI Code Tools Stall in Agency DeliveryFailure Pattern
- The Unreviewed Merge Trap: Why AI Code Tools Fail in Agency DeliveryFailure Pattern
8 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.