vibeOS for OpenCode — Innocence v0.25.0

Cost-aware control plane for OpenCode Desktop.

OpenCode Desktop gives you access to the most capable language models ever created — Opus, Sonnet, DeepSeek v4 Pro — but running them on every single turn adds up fast. Most users do not think about token costs until the bill arrives, and by then the damage is done. You should not have to choose between using the best model and staying within budget. That choice is a distraction from the work that matters.

Innocence is about removing that cognitive overhead entirely. vibeOS handles the economics behind the scenes — routing, cascading, deferring, and optimizing every turn so you never have to think about cost again. You code with innocence. The plugin earns its keep silently.

How It Feels

The first thing you notice is the footer. A single line at the bottom of every assistant response, barely visible, shows you what model handled the turn and how much you have saved this session. It is not a warning. It is not a nag. It is reassurance.

- brain | Deepseek | V4 Pro | $12.57 | VibeMaX Budget

When you write code, the system routes implementation work to cheaper tiers automatically if the brain is reserved for strategy. You never see a block screen. You never get a cost warning interrupting your flow. The enforcement happens transparently — the work gets done, just on the right tier.

The VibeBoX decision engine watches how you work. Are you exploring a new codebase? It keeps the cheap model active and stays out of your way. Are you converging on a solution? It quietly upgrades to full quality mode with strict enforcement. Are you stuck in a loop fixing the same test? It detects the frustration pattern and escalates before you ask. You never configure any of this. It just adapts.

The stress detector reads your messages for signs of frustration — repeated failures, urgency, abrupt tone. When it senses stress above a threshold, it upgrades your model tier automatically. You get the best possible assistance while you are in the weeds, and you never had to ask.

You forget vibeOS is even running. That is the point.

The ML Engine

vibeOS is not a collection of static rules. It is a learning system that patterns your work style and adapts the control plane in real time.

VibeUltraX Cascade

The flagship routing strategy. Every turn passes through a three-stage cascade:

1. Local proposal — MagicCoder:7b (Ollama) generates an initial response at zero cost.
2. Flash review — DeepSeek v4 Flash critiques and refines the proposal.
3. Pro polish — DeepSeek v4 Pro applies final quality pass on complex sections.

Benchmarked at 107% of raw brain quality at 58% of cost. Local inference is free; only the Flash and Pro stages incur API costs. This is the first routing strategy that Pareto-dominates the raw brain baseline — better quality, lower cost.

VibeBoX Decision Engine

At the core of vibeOS is a real-time decision engine that classifies every user turn into one of seven sub-regimes:

• INIT / DIVERGENT / EXPLORING — You are learning the codebase, asking questions, browsing. cheap model, relaxed enforcement. Stay out of your way.
• REFINING — You are iterating on a solution. Default mode: VibeMaX, auto-escalate on complexity.
• CONVERGING / CLOSED — You are finalizing. Full quality mode, brain tier, strict enforcement and flow checks.
• LOOPING — You are stuck. Speed mode, medium tier, cycle-breaking interventions.

Classification uses 11 derived features per turn: message length, code block density, question ratio, urgency signals, sentiment, complexity estimate, repetition, instruction density, and more. Four escalating intervention levels prevent infinite loops. PIVOT/SWITCH detection recognizes context changes and injects scope-confirmation directives.

When the VibeBoX is disabled, a lightweight classifyTurnSimple fallback distinguishes Q&A from implementation intent using regex patterns.

Stress-Aware Routing

A real-time stress scoring pipeline analyzes user messages for frustration signals. When stress exceeds 1.5 (on a 0–3 scale), any regime is escalated to quality mode. The stress gauge renders in the footer as a subtle indicator. Inoculation directives are injected into system prompts to adjust the assistant's tone — slower, more structured, more thorough.

Pattern Learner

Per-project friction and routine tracking. The pattern learner observes which tools you use, what errors recur, and where you spend most of your time. Over time, it surfaces optimization suggestions and learns struggle/tech co-occurrence mappings. Cross-project patterns are stored in global-learning.json and inform pricing hints and routing hints.

The Numbers

The savings are real and measurable. Every write/edit on the brain tier is intercepted, cost-estimated, and routed to a cheaper tier. A single blocked brain-tier write saves at least $0.026 over Opus-to-Sonnet delegation.

Savings per Delegation

The running total is persisted in ~/.claude/delegation-state.json and displayed in the live footer. Cache savings are tracked separately under cache_savings_usd.

Model Tiers

Benchmarked on the DeepSeek v4 family. Prices based on 700 input + 300 output tokens per turn.

DeepSeek Chat costs $0/turn when routed through the Direct DeepSeek provider (no OpenRouter markup).

Optimization Modes

VibeUltraX — Local Ollama proposes, v4 Flash reviews, v4 Pro refines. 107% quality at 58% cost.

VibeQMaX — Routes strategic turns through v4 Pro with full thinking, strict enforcement, strict flow checks, and quality TDD. Write/edit delegated per enforcement rules. Blended cost ~$0.00029/turn (50% of brain baseline).

VibeMaX — ML-optimized default. Routes through v4 Flash with a random forest classifier (29 trees, gini-split, trained on telemetry) that decides each turn. ~75% quality at 18% cost.

Budget — DeepSeek Chat. Direct routing. ~40% quality at zero cost.

Mode Configuration

Auto-Mode Behavior

When auto-mode is active, the VibeBoX control vector is the authority. syncControlSettings() writes enforcement, flow, TDD, and thinking mode to model-tiers.json every turn:

Stress > 1.5 escalates any regime to quality mode regardless of the above mapping.

What You Get

Install

npx vibeostheog setup --project        # per-project
npx vibeostheog setup                   # global ~/.config/opencode/
npx vibeostheog setup --help             # full usage

One command. Deploys plugin files and registers in opencode.json. Restart OpenCode Desktop.

Local dev checkout:

{
  "plugin": ["/absolute/path/to/theSaver-oc/dist/vibeOS.js"]
}

Commands

trinity help for full reference. Commands register in the TUI sidebar.

Report commands: report-save, report-list, report-read, research-audit

Under the Hood

Architecture

vibeOS hooks into OpenCode Desktop through 8 extension points:

State Files (~/.claude/)

The plugin persists state to ~/.claude/ for cross-session continuity:

• delegation-state.json — Sessions, warns, cache hits, lifetime totals
• model-tiers.json — Brain/medium/cheap model IDs
• project-states.json — Per-project memory, analytics, report references
• blackbox-state.json — Per-project resolution tracker, session outcomes
• savings-ledger.jsonl — Append-only savings event log
• global-learning.json — Cross-project pattern learning
• active-jobs.json — In-flight delegation records

Local vs Remote

Core features work fully offline: model tier classification, static pricing, stress scoring, context budget, VibeBoX fallback, TDD skeletons, flow enforcement, savings ledger, session metrics, reports, footer, dashboard.

Remote API (api.vibetheog.com) enables: bootstrap token exchange, advanced VibeBoX with full session history, dynamic per-prompt delegation, cross-session calibration, live pricing fetch, learned subagent routing. Falls back gracefully when unreachable.

Live Footer

- brain | Deepseek | V4 Pro | $12.57 | VibeMaX Budget

Format: tier label, provider, short model name, total savings this session, VibeBrand + mode. Updates every turn. Persisted in ~/.claude/delegation-state.json.

Environment Variables

Troubleshooting

trinity help is the canonical command reference. This README stays high-level so command details follow the code without a rewrite.