Stop paying to resend the same conversation.
A long thread gets resent from the top on every turn. Tileward Context keeps the history and hands the model only the part that answers the question being asked — so the answers stay sharp, the bill stops compounding, and you can see exactly which turns and documents it used.
Our own usage, read off the same dashboard you'd get.
Our own console, our own conversations. You can re-derive yours the same way.
of one long-running Claude Desktop thread never resent — 21.6M tokens of 23.8M
cut per conversation across Claude Code sessions, median ~79%
is roughly how much gets sent on a typical turn, instead of the whole history — measured across 2,487 of them
across every conversation, lifetime — 23.3M saved of 26.1M
Where it pays, conversation by conversation
| Conversation | Client | Tokens without Context cumulative resend | Tokens with Context actually sent | Never resent share saved |
|---|---|---|---|---|
| long-running assistant thread | Claude Desktop | 23.8M | 2.2M | 90.7% |
| agent session · repo work | Claude Code | 516.8k | 114.4k | 77.9% |
| agent session · refactor | Claude Code | 470.6k | 146.5k | 68.9% |
| agent session · skill authoring | Claude Code | 288.0k | 56.0k | 80.6% |
| agent session · debugging | Claude Code | 194.5k | 51.1k | 73.7% |
| agent session · long review | Claude Code | 146.2k | 6.4k | 95.7% |
| agent session · docs pass | Claude Code | 123.2k | 16.2k | 86.9% |
"Tokens without Context" is cumulative across turns, because a client without memory resends the transcript every time. Short threads have nothing to distill.
The bill is not the only thing a shorter prompt buys.
A model reads the whole prompt before it writes a token, so a shorter prompt is reading the GPU never does.
6.0× the throughput on the same server, same 16 requests, same 128 tokens of output each. Both arms measured twice, under 1% apart between runs.
Sending less doesn't mean remembering less.
Twelve facts mentioned once each in a long conversation, asked about later, including questions needing two or three of them at once.
20 of 20 answered either way, and 0 of 20 with no history at all, so the answers were coming from the conversation rather than from what the model already knew.
Routing shared state per agent role, rather than broadcasting it, held fidelity at 0.95 to 1.00 across two multi-agent flows, and the routed agents scored higher on graded answers than the agent given everything. The token saving is not quoted as a ratio yet: prompt caching is not modelled and will shrink it. See the eval, and what it does not show.
Bring your own conversation. The eval behind those figures is one graded test on one synthetic thread, and it is published with its limits. Production is not one thread: the conversations in the table above are live ones, across more than one client, and they keep accumulating. Point Context at something your team actually runs, a long support conversation or a month of agent sessions, and compare against sending the whole thing. The console shows what it pulled in and what it cost, side by side.
Three steps, about two minutes.
The install line needs a key, and the key needs an account — so here is the whole sequence rather than the middle of it. Step one is free and takes a minute.
Create a free account
No card. You get $1 of credit, 2,000 recalls and 100 MB of documents — enough to run a real thread through it.
Start freeCopy your key
Settings → API keys → create. One key works for both the /v1 API and the MCP endpoint.
Point your client at it
One line for Claude Code, a connector URL for Claude Desktop, or a deeplink for Cursor and VS Code.
Signs you in through the browser, so there is no key to copy or paste.
claude mcp add --transport http tileward-context \
https://api.tileward.com/mcp/connect
claude mcp login tileward-context
Settings, Connectors, Add custom connector, then paste this URL. Desktop signs you in through the browser too.
One click, then approve the sign-in.
CrewAI reads the tool list off the server, so the crew gets whatever Context exposes without you naming any of it.
from crewai import Agent
from crewai_tools import MCPServerAdapter
server = {
"url": "https://context.tileward.com",
"transport": "streamable-http",
"headers": {
"Authorization": "Bearer tw_live_…",
"X-Tileward-Conversation": thread_id, # one id per conversation
},
}
# the context manager opens and closes the connection
with MCPServerAdapter(server) as tools:
agent = Agent(role="Researcher", goal="…", tools=tools)
Any MCP client works. In Python the official SDK is the shortest route; anything that can hold an HTTP session can speak it directly.
Send X-Tileward-Conversation on every call. One id per conversation, the same value every time within it, a different one for a different conversation. Without it every conversation on that key shares a single store, and a recall will hand back another thread’s material as if it were this one’s. Send off for a turn you do not want remembered.
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
url = "https://context.tileward.com"
hdrs = {
"Authorization": "Bearer tw_live_…",
"X-Tileward-Conversation": thread_id, # same id every call in a thread
}
async with streamablehttp_client(url, headers=hdrs) as (r, w, _):
async with ClientSession(r, w) as session:
await session.initialize()
tools = await session.list_tools()
Authorization: Bearer tw_live_…
X-Tileward-Conversation: thread-42
Two endpoints, and the difference is how you authenticate. Browser sign-in uses /mcp/connect. A key in a header uses /mcp. Ask the server what it offers rather than hard-coding a tool list: the roster grows, and list_tools is how you find out.
Tileward Context is included with every model plan.
Context is not a separate line on the bill. Every tier on the main pricing table includes it — what changes with the tier is how many recalls you get and how much you can store.
- 2K context recalls
- 100 MB documents
- 2 keys
- 7-day audit window
- 100 requests/min
- 20K context recalls
- 1 GB documents
- 10 keys
- 30-day audit window
- 300 requests/min
- 400K context recalls
- 20 GB documents
- 3 seats · 50 keys
- 30-day audit window
- 1,000 requests/min
- 2M context recalls
- 100 GB documents
- 5 seats · 100 keys
- 1-year audit window
- No rate limit
- Committed-use pool
- Storage is your own disk
- Unlimited seats · SSO + SCIM
- Retention you set, locally
Or buy Context on its own
If you want the memory without our model. It is an MCP server and does not care which model consumes the context, so it works against Claude, GPT or your own deployment. These are a different ladder from the tiers above — hence the Context prefix.
- 50 conversations
- 2,000 recalls / mo
- 100 MB storage
- 30-day retention
- Unlimited conversations
- 100K recalls / mo
- 5 GB storage
- 1-year retention
- Unlimited conversations
- 1M recalls / mo
- 50 GB storage, shared
- Retention for the life of the account
- Unlimited conversations
- Unlimited recalls
- Storage is your disk
- Air-gapped / on-prem
Storage counts the distilled conversations and uploaded documents, not the raw transcript — which is why it goes further than it looks.
Bring us a long conversation.
We'll distill it, compare against sending the whole thing, and show you what it retrieved. Thirty minutes, an engineer, no deck.