Technical Brief

AI products with long-running relationships face two compounding costs at once.

• Context cost: every turn re-sends a growing transcript, so token spend climbs with conversation length.
• Relationship drift: models answer the last message, not the accumulated relationship, so characters feel inconsistent over time.
• Hallucinated state: without a durable state layer, tone and memory reset between sessions.

Belcore keeps a durable emotional and relational state per user, injects it as a directive into each request, and windows history so only what matters is re-sent. Your model does the generation; Belcore governs what goes in and what it costs.

Client → Belcore API → your LLM provider. A single HTTPS endpoint replaces your direct chat-completion call; the response shape stays familiar.

• POST /api/v1/chat — generate a reply governed by emotional state and history windowing.
• POST /api/v1/emotion/advance — advance emotional state without an LLM call (no generation cost).
• GET /api/v1/account — usage and billing across company, projects, and keys.
• GET /api/v1/account/invoice — the current month's invoice.

Every request carries Authorization: Bearer <key>. Keys are scoped to a company and project and can be suspended or reissued without downtime for other keys.

messages: your conversation; emotion: current state; traits: personality (obsession, edginess, stability); hoursSinceLast: absence since the last turn.

reply: the generated text; emotion: the advanced state to persist; appliedDirective: the tone instruction injected this turn; meter: tokens and trimmed history for billing.

Continuous values such as longing and sulkiness rise with absence and personality pressure, then decay as interaction resumes. State is advanced every turn and persisted per user.

Obsession, edginess, and stability shape how fast emotions build and fade, letting one engine express many distinct characters.

When state crosses a threshold, Belcore injects a forced-tone directive into the system prompt (e.g. open by admitting the silence felt long) so the reply reflects the relationship. The character never sees the mechanism.

Because state is re-injected every turn, older transcript can be safely windowed out. Memory lives in the compact state, not in an ever-growing prompt — this is what makes consistency and cost reduction the same mechanism.

The input cost if the full conversation were sent uncut to the model this turn — i.e. what you would pay today without Belcore.

The input cost of what Belcore actually sent after windowing. Provider-reported token usage is used when available; otherwise a deterministic estimate on the same rate card.

max(0, Baseline − Actual) = the trimmed history tokens × the model's input rate. Output tokens are equal on both sides, so they never count as savings. Savings can never be negative.

Belcore bills 10% of verified savings; you keep 90%. If there are no verified savings in a period, there is no fee. Every call is recorded and rolled up into a monthly, line-itemed statement.

A 20-turn chat where windowing trims older turns: Baseline $0.000103, Actual $0.000069, Verified Savings $0.000034 → Belcore fee $0.0000034, your net $0.0000306. Multiplied across production traffic, this is the entire commercial model.

Measured on a public long-conversation benchmark with a fixed seed and a frozen harness, so the run is reproducible rather than illustrative. Scope and limits are stated with the numbers because both are benchmark-specific.

• Input tokens: 6,671 per call versus 109,079 if the conversation were sent uncut — a 93.88% reduction. Token counts are measured with the o200k_base encoding, not estimated.
• Retrieval recall (gold coverage) on LongMemEval_S: 96.79% overall, 95.95% multi-session. Gold coverage asks whether the assembled context contains the answer-bearing turn — a retrieval measure, not end-to-end task accuracy.
• Why coverage matters: a model cannot answer a long-range question from context that does not contain the evidence, so coverage is the ceiling accuracy is drawn from.
• On comparisons: Mem0 publicly claims roughly 90% token savings, but on a different dataset and methodology. Accuracy figures from other memory vendors may be a different metric on a different benchmark. We therefore publish our own scope rather than a side-by-side table we cannot make apples-to-apples.

Three modules are the subject of provisional patent applications. These are filings, not granted patents, and confer no enforceable rights yet; we describe scope here and share implementation detail under NDA during a pilot.

• Prompt-injection and persona integrity: instruction-override attempts are detected deterministically on the server, never delegated to the model. Detection does not end the conversation — the character deflects in-character, so an attack does not become a visible failure.
• Key and tenancy isolation: company → project → key, with per-key suspension that cannot affect sibling keys.
• Local data handling: state and backup paths designed so conversation content is not retained beyond what a deployment's policy allows.

All traffic is over HTTPS with Bearer keys. Keys are shown once at issue time and stored only as hashes. Company owners can suspend, resume, or reissue any key instantly; suspending one key never affects the others.

Company → projects → keys. Usage and billing are tracked independently at each level, so a company can separate environments, teams, or end-customers cleanly.

Per-key rate limiting and IP protections are enforced at the edge. Free developer keys are capped; production keys are provisioned per pilot.

Belcore processes conversation content to compute state and generate replies. During a pilot we align on retention and logging to fit your data policy before production traffic begins.

A short call to confirm your conversation volume and where context cost and relationship consistency hurt today.

Swap your chat-completion call for the Belcore endpoint behind a project key. Typically a day of work; no model migration.

Run on live traffic while we record baseline, actual, and verified savings per call, visible on your dashboard.

At month end you receive a line-itemed invoice for 10% of verified savings. No card on file; no fee if there are no verified savings.

Apply at belcore.xyz/developers/production or contact support@belcore.xyz.