~./GodMode
God Mode Stack

The compiler is in the loop.

Standard agents stop at the first error. Piggy Benissy compiles.

Terminal Stream
~ _
The failure mode
An agent writes code, declares victory, and hands you something that does not compile. You find out. You paste the error back. It apologizes and writes it again.

That loop runs on your attention. Your attention is the bottleneck.
The mechanism
Every file write fires a typecheck and the tests that match that file. A failure never reaches your screen. It goes back into context as the exact error, file and line, and the model tries again. Three strikes on one file and the session escalates to a stronger model mid-flight.

You see the version that passes.
2.5B
tokens last 30 days
$34
what that cost
93%
prompt cache hit rate
310ms
gate overhead, p50
130+
tests guarding the stack
Entry

User terminal

Every session starts as a shell invocation. The persona flag is read first, and it decides which system prompt gets injected before any model is contacted.

$ god --architect "refactor the routing handler"
A single entrypoint. The flag selects the operating mode for the entire session.
Carrying shell invocation + persona flag
Control plane

god, the unified zsh harness

Sets up the environment the rest of the stack assumes: proxy configuration written, concurrency locks claimed, persona prompt loaded into position.

litellm_config_god_active.yaml
Bootstraps the proxy config so the local endpoint is live before the client starts.
/tmp/god-architect-locks
Holds architect locks so parallel sessions cannot collide on the same working tree.
Persona layer · dynamic system prompt injection
--nuculair
Investigation and exploit analysis
--aura
OSINT and passive recon intelligence
--patent
Patent engineering and prior art
--redteam
Penetration testing and security assessment
--architect
Systems design and multi-agent orchestration
system prompt five available one active
Side branch
Recon and pentest modes hand off to local Python harnesses: jwt-inspector and siblings. These run outside the model path and report back into context.
Carrying system prompt + task
Orchestration

god-architect-loop

Work is split in two. Planning never touches the codebase, and execution never re-plans. Separating them keeps a failed build from rewriting the strategy.

Phase 1
god_claude_plan
Decomposes the task, maps dependencies, and emits an execution DAG.
Phase 2
god_claude_exec
Runs tests, feeds stack traces back into context, and repeats until compilation succeeds.
plan once dag exec writes code tests fail: stack trace back into context green, exit
Carrying execution DAG + file context
Borrowed surface

Hijacked Claude CLI

The Anthropic Node SDK runs unmodified. Memory hooks bracket the session on both sides so context survives across invocations, and one variable redirects the transport.

memory-hook-start.zsh
Pre hook. Restores prior context before the first request is composed.
ANTHROPIC_BASE_URL
Points the SDK transport at 127.0.0.1:8088. Nothing else about the client changes.
memory-hook-stop.zsh
Post hook. Dumps a .compact-checkpoint for the next session to pick up.
Carrying raw JSON · messages, tools, schemas
Intercept

God proxy layer

LiteLLM plus a custom handler. Everything the client sent arrives untouched, gets compressed, and is matched to a backend before it leaves the machine.

Zero-loss passthrough · :8088
Deeply nested tool schemas survive the hop intact. Nothing is flattened or dropped in translation.
Abyss token compression
A binary intercepts the payload and compresses context before it is billed upstream.
Routing layer · intra-session model swapping

Hover any condition to trace it through to its backend.

request in _messages_have_images() _text_looks_deep() no match destination claude-fable-vision claude-fable-full fast · grok · k3 auto-swapped auto-swapped flag-selected
_messages_have_images()
Screenshots, UI captures, or any image block in the message array.
_text_looks_deep()
Prompts that read as heavy reasoning rather than quick iteration.
no match
Falls through to whichever alias the session was invoked with.
Carrying compressed context + resolved model
Upstream execution

The model layer

Five aliases, four engines. Each one answers on the Anthropic wire format, so the client upstack cannot tell which of them replied.

Auto
claude-fable-full
DeepSeek V4 Pro
Maximum reasoning. Long chains, architecture work, anything worth the latency.
Flag
claude-fable-fast
DeepSeek V4 Flash
High-speed iteration. The default for tight edit and test cycles.
Auto
claude-fable-vision
Grok-4.5
UI, screenshots, and images. Swapped in automatically when an image appears.
Flag
claude-fable-grok
Grok-4.5
Two million token context with live web search attached.
Flag
claude-fable-k3
Kimi K3
Benchmark lane via OpenRouter. Used to keep the others honest.

Nothing ships unverified.

God Mode is not a single script. It is a loop that refuses to hand you broken work.

ROUTE

The tier decides itself

A classifier reads the first turn and picks the lane. Prose and analysis go to the reasoning model, where instructions actually hold. Code goes to the fast one. Images go to the model with eyes. Then the session pins itself and stops second-guessing.

He picks once. He does not agonize.

first turn → classify → pin → session holds
GATE

The compiler answers before you do

Every write triggers mypy and the tests matching that file. Fail and the write is blocked, with the error fed straight back into context, file and line, verbatim. No summary, no paraphrase, no apology. Under 400ms on a clean write, and it fails open so it can never brick the session.

You do not get to see the broken version.

write → typecheck → tests → block or pass
ESCALATE

Three strikes and the model gets replaced

Third consecutive failure on the same file and the session rewrites its own tier mid-flight. Fast becomes Pro. The model that could not solve it is swapped for one that can, and the loop continues without a human in it.

Three strikes and he brings in something meaner.

fail ×3 → flag → tier rewrite → retry
WATCH

It audits itself and does not flatter

Every request logs tokens, cache hits, latency, and which model actually answered. Rank-based detection screams when a tier serves something weaker than it promised. A daily report reconciles local spend against provider billing and names its own blind spots.

He checks his own numbers and does not like what he finds.

telemetry → demotion detection → alarm → daily reconcile
REMEMBER

Corrections stop evaporating

Every lesson learned the hard way gets appended to a file that loads into the front of every future session. Correct it once. It stays corrected.

He does not forget. He is a pig with a changelog.

god lesson "..." → stable prefix → every session after

Piggy Benissy

Chief Architect / Omega Threat

Alias
Piggy Benissy
Origin
Terminal Multiplexer
Status
WAF-Aware Cyber-Swine
Background File
Fed a steady diet of broken API schemas and orphaned JSON lock files, he evolved past his mortal shell to become a hyper-intelligent cyber-swine.
He does not ask for permission. He merely grunts, injects a semantic circuit breaker, and forces your code to compile.
Core Directive
"Oink oink motherfucker." 
   _.-._...._.-',     _.._(`))
'-.   :::  '  /-._.-'    ',/
   )  :::    \            '.
  / *    *    |  ::        \ 
 |  \    /    /  ::         |
  \   .-.                   ;
   '-('' ).-'       ,'       ;
      '-;           |      .'
         \           \    /
         | 7  .__  _.-\   \ 
         | |  |  ``    |    |
        /,_|  |   /,_/    /
OP: PIGGY _