rig
rig is a single-binary AI agent framework that integrates any OpenAI-compatible LLM directly into the terminal. It reads and edits code files, runs tests, executes multiple tool calls concurrently, delegates long-running tasks to sandboxed background workers, schedules recurring jobs on cron, and supports custom Python plugins. The agent learns facts across sessions without prompt degradation due to persistent caching, and sessions can be paused and resumed over SSH from any device. rig is MIT-licensed, requires no runtime dependencies, and works with local models (llama.cpp, Ollama) or cloud endpoints (OpenRouter, OpenAI-compatible APIs).
rig is an AI agent, integrating with llama.cpp, llama-swap, Ollama and OpenRouter. InnovaAI rates it 4.7 of 10 for agency adoption, best for Tech Lead / CTO, Developer and Project Manager roles.
Agency Audit
rig is a single-binary AI agent framework that turns any OpenAI-compatible LLM into a coding assistant capable of reading, editing, and testing codebases autonomously. It runs locally or self-hosted, supports concurrent tool execution, background workers, cron scheduling, and Python plugins. For technical agencies with in-house development teams, rig eliminates manual handoffs between developers and AI by embedding the agent directly in the terminal workflow, reducing context-switching and accelerating repetitive coding tasks like test runs, refactoring, and documentation updates.
5recommended
30/mo
No paid plan published
Moderate
Illustrative scenario. Not a guarantee. Net capacity needs a verified paid base plan, and none is published for this service, so it is not modeled. Hours saved come from the service estimate; implementation, taxes, and unprovided usage charges are excluded.
- Tech Lead / CTO handling automated test execution and failure triage
- Developer handling codebase refactoring and boilerplate generation
- Project Manager handling background task scheduling and monitoring
- Your development team is small (1-2 engineers) or works on non-code projects; the setup and maintenance overhead of managing a local model and agent framework outweighs the time savings.
- Your agency outsources all development work to contractors or freelancers and does not maintain an in-house codebase that would benefit from persistent, session-aware automation.
- Your team relies exclusively on cloud LLMs (OpenAI, Anthropic) and lacks the infrastructure or appetite to run local models; rig's core value proposition (caching, offline resumption, self-hosted control) is lost.
Internal Adoption Path
No paid plan published
30 hr/mo
5 seats × 6 hr each
$2,250/mo
modeled at $75/hr labor rate
No paid plan published
Illustrative scenario. Not a guarantee. No verified paid base plan is published for this service, so subscription cost and net capacity are not modeled. Implementation, taxes, and unprovided usage charges are excluded.
Platform Features
Core capabilities of rig
Autonomous codebase reading and editing
rig reads and modifies code files directly from the terminal without requiring manual file selection or copy-paste. Developers and tech leads save time on context-gathering and can delegate refactoring, test fixes, and documentation updates to the agent in a single command.
Concurrent tool execution with ordered results
Multiple file reads, grep searches, and test commands run in parallel and return results in call order, collapsing what would be sequential terminal commands into a single round trip. Developers avoid context-switching delays when gathering information before asking the agent to act.
Sandboxed background workers with cron scheduling
Long-running tasks like full test suites, nightly audits, or health checks delegate to isolated worker processes that keep a transcript. Project managers and tech leads schedule recurring jobs on real cron without blocking interactive development, and can resume or inspect worker output asynchronously.
Session resumption over SSH from any device
Developers can pause an agent session on their workstation and resume it from a phone or tablet over SSH, preserving the agent's learned facts and task state. This unblocks asynchronous work and reduces friction for distributed or mobile-first teams.
Single-file Python plugins for custom tools
Teams extend rig with domain-specific tools (linters, deployment scripts, security checks) by writing a single Python file with a description, schema, and handler. Tech leads codify team standards without maintaining a fork or waiting for upstream updates.
Local-first model support with persistent caching
rig works with llama.cpp, Ollama, OpenRouter, and any OpenAI-compatible endpoint, and caches 99% of tokens across sessions. Teams running local models avoid cloud API costs and vendor lock-in while maintaining full offline capability and data privacy.
What Makes rig Different
Unique advantages vs similar tools in this niche
Single binary with no runtime dependencies and a few-hundred-line agent loop
vs Heavier agent frameworks requiring Node, Python, or container runtimesThe homepage states '417 lines is the whole agent loop, batch included' and 'no Go, no sudo'.
99% token cache hit rate across thousands of real turns
vs Agents that resend full context each turn and inflate costThe homepage claims '99% of every token served from cache, over thousands of real turns'.
Self-updating binary via rig -update
vs Manual reinstall or package-manager upgradesThe homepage shows 'rig -update keeps the runtime current' and 'updates itself in place'.
Value Equation
Outcome-likelihood-time-effort assessment for rig
Value math requires real pricing
The Value Equation (dream outcome × likelihood ÷ time × effort) feeds directly into ROI math. rig has no published pricing, so we hold this section until real numbers are available.
Contact rigPricing
Pricing data not yet available for rig.
Reality Check
rig requires your team to adopt terminal-based workflows and maintain familiarity with the agent's task-board syntax and session-resumption patterns. Payoff is highest for teams already running local or self-hosted models; teams relying solely on cloud APIs will see less operational advantage since rig's caching and offline-resume benefits depend on persistent local infrastructure.
Moderate effort: standard configuration with some customization needed
How This Accelerates White-Label Services
Who It's For
- ✓agencies-with-in-house-development-teams
- ✓technical-agencies-running-local-or-self-hosted-models
- ✓teams-automating-repetitive-coding-and-testing-tasks
Acceleration Steps
- 1Create your account and complete setup wizard
- 2Configure read and edit codebases autonomously from the terminal
- 3Connect llama.cpp
- 4Launch your first client project
Academy for rig
Work through it in order: the course for this service first, then the modules behind it.
Course for this service
Rig Agency Implementation, Productized AI Code Automation
Learn how to package Rig's autonomous codebase reading, concurrent tool execution, and background worker scheduling into retainer services for development teams. This course covers client onboarding workflows, custom Python plugin development for agency-specific tasks, and pricing models for ongoing code maintenance and test automation delivered through the agent.
Open the courseNo 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.
- Wiring Over WidgetsConcept
The AI agent itself is a commodity, but the value for agencies lies in the integration layer: connecting a pre-built agent to a client's CRM, calendar, and review cycle. This framework shifts focus from selecting the 'best' agent to mastering the wiring process. For example, an agency using Vendasta's white-label AI receptionist for a local business must configure it to match the client's booking rules and follow-up cadence, turning a generic tool into a tailored service. As agentic AI adoption grows (77% of decision-makers now run agents in production), clients expect this customization. Agencies that treat agents as components and invest in repeatable wiring processes can charge retainers for ongoing optimization, rather than one-off setup fees.
- Wiring Over WidgetsConcept
The AI agent market sells finished workers, but the strategic value for agencies lies not in the agent itself, which is increasingly a commodity, but in the wiring that connects it to a specific client's CRM, calendar, and review cycle. This framework, 'Wiring Over Widgets,' argues that agencies that treat agents as components rather than products win. The agent is the widget; the wiring is the integration, customization, and ongoing optimization that turns a generic tool into a tailored solution. For example, a white-label platform like Vendasta provides AI employees, but the agency's role is to configure them for each local business's unique lead flow and follow-up process. This wiring is where retainer pricing originates, as it requires ongoing maintenance and adjustment. Recent research shows that 88% of B2B marketers face foundational gaps, meaning clients need help not just deploying agents, but ensuring their operations can support them. Agencies that master the wiring can charge a premium for the irreducible value they add.
- Wiring Premium Over Agent CommodityConcept
Pre-built agents are converging on the same underlying model capability, so the agent itself prices toward zero. What holds value is the wiring: the mapping of a specific client's CRM fields, calendar rules, escalation paths, and review cadence into the agent's loop. Agencies that sell the agent as the product compete on seat price against every reseller of the same worker. Agencies that sell the wiring charge for discovery, field mapping, exception handling, and monthly tuning, which is retainer work. Vendasta's white-label AI workforce and Relevance AI's pre-built sales agents both arrive configured out of the box, which means the configuration is not the moat; the client-specific plumbing is. A practical test: if a competitor could swap your agent vendor next quarter without the client noticing, you sold a commodity. If the swap would break their CRM hygiene, approval chain, or reporting, you sold wiring.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- AI Agents Rule: Wire the Agent, Not the ProductEvaluation Rule
Treat the AI agent as a commodity component and focus your value on the integration into the client's specific workflows, systems, and review processes.
- AI Agents Rule: Wire the Agent, Not the ProductEvaluation Rule
Treat the AI agent as a commodity component and charge for the integration into the client's specific systems and workflows.
- AI Agents Decision: Resell a Finished Agent vs Wire Agents Into Client SystemsDecision Framework
IF your client roster shares one repeatable function (lead capture, review requests, inbox triage) and you can resell a white-label agent without touching their stack, THEN package the finished agent as a low-configuration productized service. IF each client's value sits in the wiring between the agent and their CRM, calendar, and review cycle, THEN sell the integration as the deliverable and treat the agent itself as a replaceable component.
- The Productized Agent Trap: Why AI Agent Services Stall Without Client-Specific WiringFailure Pattern
- The Demo-to-Retainer Gap: Why AI Agents Stall After the Pilot CallFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Agentic Intake Triage Offer (10-14 days)Implementation Blueprint
A fixed-scope deployment that puts a pre-built agent in front of inbound leads, support tickets, or document queues, then wires its output into the client's CRM, calendar, and review cycle. Priced as a setup fee plus a monthly retainer for monitoring and tuning.
- Agent Scope Contract (Onboarding)Operating Procedure
- Agent Access Provisioning and Data Boundary Check (Onboarding)Operating Procedure
12 modules selected for rig
Frequently Asked Questions
Answers about pricing, setup, implementation
rig is a lightweight AI agent framework that runs as a single binary and turns any OpenAI-compatible LLM into a coding assistant. It reads and edits codebases autonomously, runs tests, executes tool calls concurrently, delegates long-running tasks to sandboxed workers, schedules recurring jobs on cron, and supports custom Python plugins. Sessions persist across device boundaries and can be resumed over SSH, and the agent learns facts across turns without prompt degradation.
rig is distributed under the MIT license and is free to download, install, and use. There is no per-seat pricing, subscription, or commercial license required for internal adoption by agencies.
Tech leads and CTOs benefit by embedding the agent directly in their development workflow and avoiding vendor lock-in through local model support. Developers save time on repetitive coding tasks like test runs and refactoring. Project managers and operations staff reduce handoff friction by keeping agent coordination in the terminal. Founders of technical agencies lower operational costs by automating internal coding work without cloud API fees.
Conservative estimate is 4-8 hours per developer per month, depending on the volume of repetitive coding tasks (test runs, boilerplate refactoring, documentation updates) that the team delegates to the agent. Teams running local models and scheduling background workers see higher savings because they avoid context-switching and API latency. Actual payoff depends on adoption discipline and the team's willingness to frame work as agent-delegable tasks rather than manual coding.
Yes, rig supports any OpenAI-compatible endpoint, including OpenAI, Anthropic (via OpenRouter), and other cloud providers. However, rig's core advantages (persistent caching, offline resumption, data privacy, cost control) are most pronounced when running a local model like llama.cpp or Ollama. Cloud-only teams will still benefit from concurrent tool execution and session resumption, but will not recoup the setup overhead as quickly.
Installation takes 2-5 minutes (one curl command). Configuration requires editing three JSON files to specify your model endpoint, token budgets, and optional worker settings, which takes 10-20 minutes for a tech lead. Onboarding developers to the terminal workflow and task-board syntax typically takes 1-2 hours of hands-on training. Total time to production for a 5-person dev team is roughly 4-6 hours.