vibeOS for OpenCode

Prices validated: May 28, 2026 — verified against OpenRouter /api/v1/models

Cost-aware control plane for OpenCode Desktop. Keeps expensive models on strategy, routes implementation to cheaper tiers, surfaces savings in real time.

For teams, vibeOS adds practical guardrails: delegation enforcement, flow and TDD controls, pattern learning, stress-aware routing, VibeBoX decision tracking, reporting, and remote API protection for the core algorithms.

Delegation Enforcement

Every write/edit/notebookedit on the brain tier is intercepted, cost-estimated, and blocked with a visible enforcement note. Work must be delegated to medium or cheap. This is the primary savings mechanism.

Per-Turn Cost (700 input + 300 output tokens)

Source: src/lib/pricing.ts:279-285. Conservative estimates — actual OpenRouter live: Opus $0.011, Sonnet $0.0066, Haiku $0.0022 per turn. The plugin over-estimates brain cost so savings are always understated.

Savings per Delegation

Every blocked brain-tier write/edit saves at least $0.026 (Opus→Sonnet). The running total is tracked in ~/.claude/delegation-state.json and displayed in the live footer.

VibeBoX Optimization Modes

Benchmarked on the DeepSeek v4 family — the default model stack for vibeOS.

Model Pricing (700 input + 300 output tokens)

Mode Comparison — All Modes vs Raw Top Tier

Cost vs Quality Visual

The raw model (v4 Pro, full thinking) sets the quality baseline. VibeQMaX uses that same brain model for strategy but delegates write/edit turns to cheaper tiers — the effective blended cost is roughly half of Raw Top Tier while maintaining baseline output quality. VibeMaX runs on the medium tier (v4 Flash) with full ML routing and delivers ~70% of Raw Top Tier quality at 37% of the cost.

Quality
  baseline  ● Raw Top Tier · VibeQMaX
  ~70%      │   ● VibeMaX ⭐
  ~55%      │   ● speed
  ~40%      │   ● budget
            │
            └────────────────────────
            1.0x  0.50x 0.37x 0.32x 0.26x
                        Cost Multiplier

Branded Modes

VibeQMaX (Quality Max) — The highest-assurance configuration. Routes strategic turns through deepseek/deepseek-v4-pro with full thinking, strict enforcement, strict flow checks, and quality TDD. Write/edit turns are delegated to cheaper tiers per enforcement rules, yielding an effective blended cost of ~$0.00029/turn (≈50% of Raw Top Tier). Guardrails include: delegation enforcement blocks costly mistakes, flow pattern validation prevents structural issues, TDD skeleton generation ensures test coverage, and context7 optimization reduces context waste. VibeQMaX maps to the system's quality mode — brain-tier settings with the full vibeOS control plane active.

VibeMaX (ML-Optimized) — The intelligent cost-quality sweet spot. Routes through deepseek/deepseek-v4-flash (medium tier) and uses a random forest classifier (29 trees, gini-split, trained on telemetry) to decide each turn whether to apply optimized (full quality) or budget (fast/cheap) treatment. Classifies on 11 derived features: message length, code block density, urgency signals, complexity, instruction density, question ratio, and more. Trained via trainVibeMaXModelFromTelemetry() on real session data with bootstrap fallback. PivotCache integration detects return-to-workflow patterns and restores prior context. Benchmarked at ~70% of Raw Top Tier quality at 37% of the cost.

Benchmark Details

All tests run with deepseek/deepseek-v4-pro (brain), deepseek/deepseek-v4-flash (medium), and deepseek/deepseek-chat (budget). Quality scores measured against Raw Top Tier (v4 Pro, full thinking, no vibeOS overhead). VibeMaX quality benchmark derived from real session telemetry with bootstrap confidence intervals.

Features

How It Works

8 hooks into OpenCode Desktop:

Local vs Remote

Full Local (no token)

Model tier classification, static pricing (~20 models), stress scoring, context budget, turn classification, TDD skeleton gen, flow enforcement, savings ledger, session metrics, reports, footer, dashboard, smart cache, VibeBoX fallback.

Requires Remote API (api-token)

Bootstrap token exchange, advanced VibeBoX with full session history, dynamic per-prompt delegation, cross-session calibration, live pricing fetch beyond static map.

Local Fallback Mode

Without a token, vibeOS keeps running in local-only mode with bundled algorithms. Here's what works locally versus what requires the remote API.

Fully Functional Locally

• Model tier classification (brain / medium / cheap)
• Static pricing for ~20 common models
• Stress scoring, context budget estimation, and turn classification
• TDD skeleton generation, text compression, and flow enforcement
• Savings ledger, session metrics, reports, and footer/dashboard rendering
• Session-scoped smart cache for duplicate tool output detection

Requires Remote API

• Bootstrap token exchange (required for initial API setup)
• Advanced VibeBoX decision engine with full session history tracking
• Dynamic per-prompt delegation decisions (local fallback uses a safe "block all writes on high tier" default)
• Learned subagent routing patterns across projects (local fallback uses a static exploratory keyword list)
• Optimization mode selection via advanced VibeBoX (local fallback uses rule-based selection)
• Aggregated cross-session calibration and model retraining
• Live pricing fetch for models beyond the hardcoded map

When the remote API is unreachable, the plugin degrades gracefully to rule-based local algorithms. Core enforcement features continue working — the plugin stays functional and safe, just less adaptive in its routing and mode decisions.

Install

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

Adds vibeostheog to opencode.json. Restart OpenCode Desktop.

Local dev checkout:

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

Commands

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

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

Live Footer

— Model: claude-sonnet-4-6 | Provider: Anthropic | $4.82 saved | $1.20 cached | ENFORCE | LOCK | Quality | VIBE —

Provider, model, delegation savings, cache savings, stress gauge (block chars), lock/enforcement tags, optimization mode. Persisted in ~/.claude/delegation-state.json.

Architecture

Plugin Source

Single-file runtime src/index.js (5529+ lines). TypeScript source of truth at src/vibeOS-lib/*.ts and src/utils/*.ts. Build: npm run build (tsc + esbuild bundle + deploy script).

State Files (~/.claude/)

VibeBoX Decision Engine

7 sub-regimes (INIT, DIVERGENT, EXPLORING, REFINING, CONVERGING, CLOSED, LOOPING). Classification via entropy trends, action consistency, feature contradiction, embedding drift. 11 derived features per turn. 4 loop intervention levels. PIVOT/SWITCH detection. Outcome tracking from satisfaction signals.

Regime→mode mapping via syncControlSettings():

Stress > 1.5 escalates any regime to quality.

Remote API Server

src/vibeOS-api-server/ — Fastify + SQLite at api.vibetheog.com. Endpoints: delegation check, tier routing, stress scoring, VibeBoX analysis/calibration, TDD skeleton gen, pattern observation, pricing fetch, context compression. Auth via VIBEOS_API_TOKEN. Client: src/vibeOS-api-server/client.js with automatic local fallback.

Dashboard

SolidJS SPA at src/dashboard/. Build: npm run build:dashboard (vite). Served by MCP server or standalone. SSE /events for real-time push (model split, savings, session history, stress, VibeBoX state).

Environment Variables

Troubleshooting

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