FastRecall

FastRecall is a context storage and recall API for applications that use multiple AI models, routers, or agents. It gives developers a provider-independent place to keep ordered conversation history, then returns model-ready context for each new request. The problem it addresses appears when an application switches from one model or provider to another. Provider-specific sessions and prompt caches don't travel cleanly, while repeatedly rebuilding a long prompt adds application logic and can waste tokens. FastRecall keeps a portable history as the source of truth, so the surrounding product can change models without abandoning the conversation that came before.

The normal integration follows a three-step cycle. An application first calls the recall endpoint with only the new, unstored input. FastRecall returns an OpenAI-compatible messages array containing the instructions, relevant stored history, pinned items, and incoming message. The application sends that array directly to its chosen model provider, then calls the store endpoint with the new user input and successful model output. FastRecall does not proxy the model call, host models, or hold the developer's provider API keys. That separation keeps model selection and inference billing in the application while the service handles the context layer.

For ordinary histories, replay mode returns the complete portable prompt. Automatic memory mode can keep doing that until a context reaches the documented watermark of one million estimated tokens. Above that point, it switches to a hybrid response with the newest 800,000 estimated tokens kept verbatim, plus stable instructions, pinned items, complete tool pairs, and relevant evidence from older history. Developers can also request FlashCompact explicitly. This model-free retrieval mode builds a smaller context from recent turns and selected evidence without calling another language model for summarization, which is intended to reduce the added cost, latency, and retrieval errors associated with generative compaction.

FastRecall also supports native continuation for compatible provider workflows. An application can store opaque provider state, such as a continuation identifier, alongside a completed turn. If the branch head, instructions, provider, exact model, and caller-defined configuration still match on the next request, recall returns only the new input delta and the saved checkpoint. That lets the application use provider-side caching or continuation while still preserving portable messages. If those conditions no longer match, FastRecall falls back to a full replay. Native checkpoints are branch-local and cannot be combined with FlashCompact.

The API has several controls that make it suitable for agent and production workflows rather than only chat demos. Every context can carry stable instructions and caller-defined metadata, and individual items can be pinned. Conversation branches inherit history through a chosen sequence, then advance independently, which helps with alternate agent plans or speculative paths. Store requests support idempotency keys for safe retries, while an expected head sequence detects concurrent writers before stale output is appended. API keys can be scoped separately for reading, writing, and permanent deletion. A lossless JSON export includes contexts, branches, checkpoints, and stored items when a team needs to inspect or move its data.

The product is for developers building model routers, multi-agent systems, support assistants, and long-running AI features where continuity matters across calls. It isn't a consumer chat interface and it doesn't choose or call a model on the user's behalf. Teams still need to manage provider accounts, generation requests, failures, and token charges. They also need to decide which memory mode matches each workload. Full replay preserves fidelity but sends more context, FlashCompact is selective by design, and native continuation depends on an exact provider configuration match. The documentation provides REST examples as well as JavaScript and Python guides, but integrating it still requires application code around recall, inference, and store.

New users get one week of sandbox access with the full platform and no credit card. Paid access is usage-metered with a monthly minimum. Hobbyist starts at $2 per month and supports up to 25 contexts, Hacker starts at $7 with up to 250 contexts, and Developer starts at $25 with unlimited contexts. Each invoice is the greater of the plan minimum or measured storage usage, recalls are included, and charges from model providers remain separate. This structure makes initial experiments inexpensive, but teams should use the site's calculator to estimate storage at their expected context count and message depth. The low entry price is appealing, while the real fit depends on whether a project needs durable cross-model context badly enough to add a dedicated memory service.