Trooper started as a proxy for Claude API calls. When quota hits, it falls back to local Ollama with context preserved.

Today it handles real human conversations — and I shipped a feature worth talking about.

**The scenario:**

You're mid-conversation with Claude through Trooper. Architecture decisions, authentication design, system planning. Everything going to the cloud.

Then a sensitive detail comes up. An internal service URL. A proprietary system. Something you'd rather not send outside your machine.

Previously your only options were stop the conversation or send it anyway.

**Now there's a third:**

    "x_force_local": true

One field in the request body. That specific message routes to local Ollama with full session context intact. Next message goes back to Claude automatically. No restart. No lost context. No interruption.

**Left terminal** — a real conversation. Four turns. Claude handles architecture and auth questions. Developer types `local`. Sensitive vault URL stays on machine — Ollama answers it locally. Claude summarises after.

**Right terminal** — Trooper routing decisions in real time:

    🔒 Developer requested local-only (x_force_local) — skipping cloud
    🔒 Local: ollama (force_local) | privacy mode | session saved: 18 tokens

**What actually happened with the vault detail:**

The raw vault URL never left the machine - Ollama handled it locally. Trooper's SITREP then created a compressed abstraction of the session state. Claude received that abstraction, not the raw message.

**What's different here vs LiteLLM or Bifrost:**

The individual pieces exist elsewhere — local routing, fallback, context compression all appear in fragments across different tools. What's different is the composition:

A session-stateful LLM router that enables per-turn execution locality with a shared compressed memory layer enabling cross-provider continuity.

The differentiator: execution locality is a runtime decision inside a persistent conversation state machine.

They route between clouds. Trooper routes to your machine. Per message. Mid-conversation. Without breaking anything .

**Three reasons to use** `x_force_local`**:**

* Privacy — sensitive payload never leaves the machine
* Cost control — force expensive turns to local
* Offline mode — keep working when cloud is unavailable

**How context is preserved:**

Trooper uses a 3-layer memory system across provider switches:

* **Anchor** — first 2 turns, always preserved verbatim
* **SITREP** — compressed abstraction of middle turns
* **Tail** — recent turns within token budget

The local model always knows where the conversation was — without receiving raw history from the cloud session.

Repo: [https://github.com/shouvik12/trooper](https://github.com/shouvik12/trooper)

Trooper went from API proxy to handling real Claude conversations- mid-chat, one flag, sensitive messages never leave your machine