We automate the AI that automates us.

136 error patterns. Zero tokens. The AI pays once, CyxCode remembers forever.

• What is CyxCode?
• Quick Start
• Two Modes
• Pattern Learning
• Project Memory
• Dream Consolidation
• Supported Categories
• Environment Variables
• Why Fork?
• Docs & User Guide
• Roadmap

CyxCode is a fork of OpenCode that intercepts known errors before the LLM sees them. 136 regex patterns match common errors and provide instant fixes — for free.

Traditional AI:  Every error -> LLM -> tokens burned -> response
CyxCode:         Every error -> Pattern check -> match? -> FREE fix
                                               -> no match? -> AI learns it

When no pattern matches, the AI handles it normally — but CyxCode captures the error + fix and generates a new pattern. Next time, that error is free. The pattern library grows automatically.

git clone https://github.com/code3hr/cyxcode.git
cd cyxcode
bun install
export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY
bun run dev

For CPUs without AVX2, see AVX2 Note.

!python3 -c 'import flask'
  -> Runs directly (no AI)
  -> CyxCode matches pattern
  -> Fix displayed instantly
  -> Tokens: ZERO

python3 -c 'import flask'
  -> AI thinks "let me run this" (LLM Call #1)
  -> CyxCode matches -> LLM Call #2 SKIPPED
  -> Tokens saved: ~800-1600 per error

When CyxCode misses a pattern, the AI handles it. But CyxCode learns from that interaction:

1. AI handles the error (costs tokens once)
2. CyxCode captures the error output + AI's fix
3. Generates a regex pattern automatically
4. Saves to .opencode/cyxcode-learned.json as pending
5. Run /learn-patterns to review and approve

Run /learn-patterns to review pending patterns. Each shows the error, generated regex, fix, and source command. Approve to activate, reject to discard, or skip for later.

The screenshot shows a bun 404 error being caught by a learned pattern. This error was handled by the AI the first time (costing tokens). CyxCode captured it, generated a pattern, and after approval via /learn-patterns, it now matches automatically — the AI is short-circuited and the fix is displayed directly. 6. Next time same error occurs -> zero tokens

Every AI-handled error becomes an investment — that error never costs tokens again.

The AI forgets everything between sessions. CyxCode fixes that with indexed project memory — small files that load selectively based on what you're working on.

Run /remember to save project knowledge. The AI detects duplicates, extracts tags, and stores compact 1-5 line memories in .opencode/memory/. Each memory has tags for relevance matching.

Session 1: /remember "auth.ts uses JWT with bcrypt, middleware at line 50"
           -> Saved to .opencode/memory/auth-jwt-bcrypt-middleware.md
           -> Tagged: [auth, jwt, bcrypt, middleware]

Session 2: "what does auth.ts do?"
           -> Memory auto-loaded (keyword "auth" matches tag)
           -> AI already knows: "JWT with bcrypt, line 50"
           -> Skips reading the file -> tokens saved

Memories are also captured automatically when sessions compact. The compaction summary's "Discoveries" and "Relevant files" sections become indexed memories.

CyxCode accumulates state over time — memories, patterns, stats. /dream cleans it up, like sleep for AI.

• Deduplicates learned patterns (removed 2→1 duplicate on first run)
• Merges overlapping memories
• Validates file existence and regex
• Persists router stats to .opencode/cyxcode-stats.json

• All auto-dream phases plus smart merging
• Updates AGENTS.md with learnings from patterns and memories
• Reports: matches, misses, hit rate, tokens saved, sessions tracked

3 skills, 16 categories, 136+ patterns:

Full pattern breakdown: docs/ADDING-PATTERNS.md

Plugins can't do what CyxCode does:

1. Short-circuit requires modifying the core loop — plugins can't break the LLM loop
2. Shell mode (!) has no plugin hook — SessionPrompt.shell() is a core function
3. Tool result metadata — cyxcodeMatched flag requires bash tool internals
4. Module initialization timing — Bun's --conditions=browser needs imports in core files

Plugins decorate. CyxCode changes control flow. That requires a fork.

CyxCode is a fork of OpenCode. You'll see opencode in some internal files — directory names (.opencode/, packages/opencode/) and internal code references. This is intentional.

A full rebrand of every internal reference would make it impossible to pull upstream improvements from OpenCode. We regularly sync with upstream to get new features, bug fixes, and TUI improvements. Renaming thousands of internal references would turn every git pull into a merge conflict nightmare.

What's been rebranded: the CLI (cyxcode), the TUI logo, the package scope (@cyxcode/*), feature flags (CYXCODE_*), config files (cyxcode.jsonc), database (cyxcode.db), and all documentation. The directory structure stays opencode internally for upstream compatibility.

If you see opencode in a directory path or source file, that's normal. If you see it in the UI or docs, that's a bug — please report it.

Available at http://localhost:4096/dashboard when running in web/server mode. See docs/PENTEST.md for full API reference.

MIT License — See LICENSE

Tokens are the new currency. CyxCode makes sure you don't waste them.

CyxCode — We automate the AI that automates us.