# How Reasonix Optimizes Token Costs Using DeepSeek Prefix Cache

> Reasonix optimizes DeepSeek token costs by caching immutable prefixes, slashing expenses by ~75% compared to fresh inputs. Learn how this technique reduces API call expenses.

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: how-to-guide
- Published: 2026-08-04

---

**Reasonix slashes DeepSeek token costs by preserving immutable prefixes across API calls, ensuring cached tokens are billed at ~75% lower rates than fresh input tokens.**

Reasonix is an open-source AI orchestration framework that exploits DeepSeek's **prefix cache** to minimize per-request expenses. DeepSeek's pricing model charges significantly less for tokens that hit the cache (e.g., ¥0.5 per 1M cached tokens versus ¥2 per 1M uncached tokens). By architecting conversations to maximize cache hits, Reasonix shifts the majority of token costs to the cheaper cached rate.

## Understanding DeepSeek's Prefix Cache Mechanism

DeepSeek's prefix cache stores the **system prompt and conversation history** on the provider side using a cache key derived from the prefix content. When an identical prefix appears in subsequent requests, DeepSeek reuses the cached computation and charges the reduced cached-token rate.

The cache activates when:

- The **system prompt** remains byte-for-byte identical across calls
- The **message sequence** from the start of the conversation is preserved without modification
- No intermediate tokens are inserted that would shift the prefix boundary

Only tokens *after* the cached prefix—typically new user queries—are billed at standard input rates.

## How Reasonix Maximizes Prefix Cache Hits

Reasonix implements four core strategies to keep the prefix cache "warm" and minimize expensive uncached token consumption.

### Stabilizing the System Prompt

Reasonix never mutates the system prompt mid-conversation. In [`internal/provider/provider.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/provider.go), the provider-visible conversation structure maintains a fixed prefix:

```go
// internal/provider/provider.go
// The system prompt and prior transcript form the prefix cache key.
// Changing either invalidates the cache and triggers full input pricing.
type Conversation struct {
	SystemPrompt string    // Immutable once established
	Transcript   []Message // Appended, never rewritten
}

```

This static system prompt ensures the cache key remains stable across all turns in a session.

### Preserving Conversation Transcript Order

The guardian component in [`internal/guardian/guardian.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/guardian/guardian.go) manages transcript integrity:

```go
// internal/guardian/guardian.go
// system prompt and prior transcript stay in the prefix cache
type Guardian struct {
	systemPrompt string
	transcript   []Turn // Strict append-only, no reordering
}

```

By enforcing **append-only semantics** on the transcript, Reasonix guarantees that the cached prefix grows predictably. Each new turn extends the cacheable region rather than invalidating it.

### Detecting Cache-Invalidating Changes

When sessions resume, Reasonix validates prefix continuity. In [`desktop/session_prompt.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/desktop/session_prompt.go), the system warns when changes would trigger a cache miss:

```go
// desktop/session_prompt.go
func (sp *SessionPrompt) ValidateResume(newPrompt string) {
	if !strings.HasPrefix(newPrompt, sp.storedPrefix) {
		slog.Warn("desktop: resume swapped a differing system prompt; conversation prefix cache will miss")
		// Cache miss → all tokens billed at full input rate
	}
}

```

This detection prevents users from inadvertently doubling their token costs through configuration changes.

### Warm-Up Persistence Across Restarts

The controller persists guardian state to maintain cache warmth. From [`internal/control/controller.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/controller.go):

```go
// internal/control/controller.go
func (c *Controller) Stop() {
	// Persist guardian session so prefix cache stays warm after restart
	state := c.guardian.Serialize() // Captures full prefix
	c.stateStore.Write(state)
}

func (c *Controller) Start() {
	state := c.stateStore.Read()
	c.guardian = NewGuardian(state) // Restores identical prefix
}

```

By serializing and restoring the complete conversation prefix, Reasonix ensures that **restarts do not reset cache eligibility**.

## Practical Implementation Example

A typical Reasonix interaction demonstrates the cost-optimized flow:

```typescript
// Initial request establishes cacheable prefix
const initialRequest = {
	model: "deepseek-v4-flash",
	system: "You are a cybersecurity analyst specializing in vulnerability assessment...",
	messages: [
		{ role: "user", content: "Analyze this log for threats." },
		{ role: "assistant", content: "I've identified three suspicious patterns..." }
	]
};

// Subsequent request reuses prefix, pays only for new tokens
const followUpRequest = {
	model: "deepseek-v4-flash",
	system: "You are a cybersecurity analyst specializing in vulnerability assessment...", // Identical → cache hit
	messages: [
		{ role: "user", content: "Analyze this log for threats." },
		{ role: "assistant", content: "I've identified three suspicious patterns..." },
		{ role: "user", content: "Dig deeper on pattern #2." } // Only these tokens billed at full rate
	]
};

```

The first two messages plus system prompt are retrieved from cache at cached-token pricing. Only the final user message incurs standard input costs.

## Cache Hit Rate Impact on Costs

| Scenario | Token Pricing | Relative Cost |
|----------|-------------|---------------|
| Cold start (no cache) | Full input rate (¥2 / 1M) | 100% baseline |
| Prefix cache hit | Cached rate (¥0.5 / 1M) | 25% of baseline |

For long conversations where 90% of tokens fall within the cached prefix, **effective token costs approach the cached rate floor**. Reasonix's architecture ensures this ratio remains stable across session lifetimes.

## Key Source Files

- [`internal/provider/provider.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/provider/provider.go) — Provider interface and prefix cache integration
- [`internal/guardian/guardian.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/guardian/guardian.go) — System prompt and transcript management
- [`desktop/session_prompt.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/desktop/session_prompt.go) — Cache invalidation detection and warnings
- [`internal/control/controller.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/controller.go) — Guardian persistence for cross-restart cache warmth

## Summary

- **Reasonix optimizes token costs** by engineering conversations for maximum DeepSeek prefix cache utilization
- **Static system prompts** eliminate cache key variation across requests
- **Append-only transcripts** extend the cached prefix rather than invalidating it
- **Resume validation** warns users when configuration changes would trigger expensive cache misses
- **State persistence** maintains cache eligibility across application restarts

The result is predictable, minimized token pricing where the majority of conversation history is billed at DeepSeek's discounted cached-token rate.

## Frequently Asked Questions

### What happens if I change the system prompt mid-conversation?

Reasonix detects this in [`desktop/session_prompt.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/desktop/session_prompt.go) and logs a warning: the prefix cache will miss and subsequent requests incur full input-token pricing for the entire conversation history. The system prevents automatic prompt mutation to avoid accidental cost spikes.

### Does the prefix cache work across different DeepSeek models?

No. The cache key is model-specific. Reasonix maintains separate guardian sessions per model, and switching models (e.g., from `deepseek-v4` to `deepseek-v4-flash`) creates a new cache context with cold-start pricing.

### How much can Reasonix actually save on token costs?

Savings scale with conversation length. For a 50-turn conversation where 95% of tokens fall within the cached prefix, effective costs approach the cached-token rate (¥0.5 / 1M versus ¥2 / 1M), yielding approximately **75% reduction** versus an equivalent uncached implementation.

### Is prefix data stored locally or on DeepSeek's servers?

The cached computation resides on DeepSeek's infrastructure. Reasonix stores only the **conversation state** (system prompt and transcript) locally, serialized in [`internal/control/controller.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/controller.go). This local state enables the client to recreate identical prefixes, triggering cache hits without transmitting redundant context.