Governed memory.
Organizational control.
Put explicit rules around the knowledge your agents use. Track claims, preserve provenance, separate project context, and keep people in the review loop.
Memory governed at every step.
Admission rules. Claim lifecycles. Source provenance. Recall Racoon separates reasoning from memory policy, with explicit controls over what enters the Stash and how it returns to your agents.
Control Plane
Enforce memory policies separately from model reasoning. Keep admission, conflict handling, and retrieval rules explicit.
Claim Lifecycle
Track candidate, confirmed, stale, superseded, conflicted, and archived claims. Keep changing knowledge under review.
Provenance & Audit Trails
Track sources and memory operations. Inspect the context behind a claim and the record of how memory changes.
Conflict Review
Surface conflicting information. Apply resolution policies. Bring people into the loop when review is needed.
Need a custom deployment?
Your infrastructure sets the boundaries. Your workflows define the requirements. Discuss governance, integration, and deployment with us.
Your environment.
Your requirements.
Start with the environment your team needs. Define the deployment scope and operating responsibilities before implementation.
Cloud Managed
Discuss hosting, data handling, support access, and operational responsibilities for a managed environment.
- Hosting requirements
- Data handling boundaries
- Operational responsibilities
Private VPC
Plan a deployment within your private cloud environment. Define networking, access, integrations, and the operating model.
- Private network requirements
- Access and integration boundaries
- Operations planning
On-Premise
Run Recall Racoon on infrastructure you control. Configure local processing, memory storage, monitoring, and backups for your environment.
- Local infrastructure
- Configured local models
- Memory and backup operations
Air-Gapped
Define offline requirements before deployment. Review model availability, integrations, updates, and every dependency on external connectivity.
- Offline operation requirements
- Model and dependency planning
- Update and support procedures
Control across the
memory workflow.
Memory admission and policy enforcement
Claim lifecycle and conflict handling
Provenance and source context
Project and user namespaces
Encrypted credential handling
Mission Control for memory and session management
Memory and session export
Service monitoring and scheduled backups
A claim lifecycle you
can trace.
Every piece of knowledge that enters Recall Racoon moves through an explicit claim lifecycle. A claim starts as a candidate and becomes confirmed when it is accepted. As underlying information changes, a claim can be marked stale, and when newer information replaces it the claim is superseded rather than silently overwritten. Conflicting claims are flagged and routed for review, and claims that are no longer relevant are archived instead of deleted. Each transition preserves the relationship between the original claim and what replaced it.
Provenance travels with every claim. Source context, citations, and the record of memory operations stay attached, so teams can inspect not just what an agent recalls, but where that knowledge came from and how it changed over time. When two sources disagree, the conflict is surfaced for human review rather than resolved in the background.
Separate projects.
Scoped recall.
Namespaces keep user and project memory separate, so retrieval stays within the scope your teams intend. Memories are organized with project scope, categories, tags, source details, and agent metadata. When a connected agent searches, it retrieves from the scope it was configured for rather than a shared, undifferentiated pool of knowledge.
Durable knowledge lives in the Stash, while temporary working state lives in namespaced sessions with configurable expiry. When work resumes in a new session, persistent memory and session state let connected agents pick up saved context where they left off. This gives organizations both long-term institutional memory and short-term working memory, kept in distinct places with distinct rules.
Secrets never live in
ordinary memory.
Incoming memory is checked for supported secret patterns, including API keys and access tokens, passwords and credential-bearing connection strings, private keys, and supported card-number patterns with validation. When the encrypted credential vault is available, detected values are stored encrypted and replaced with references in memory. When the vault is unavailable, detected values are redacted and the remaining nonsecret content is preserved.
Credentials are managed by project and kept separate from ordinary memory content. This keeps sensitive values out of the knowledge your agents recall while preserving the useful context around them, and it gives teams a clear record of where credentials live and how they are handled.
Visibility over
memory operations.
Recall Racoon surfaces service health, usage metrics, and memory operations through health checks and daily status reports. Teams can review what is happening in the Stash, inspect source context, and manage changes through the available interfaces. This keeps project scope and governance visible as workflows grow.
Recovery is part of the operating model. Memory backups can be scheduled with configurable retention, and optional offsite mirroring supports a recovery strategy that matches your requirements. Together these controls help organizations plan for continuity rather than treating memory as an afterthought.
Rules, review, and
a working view.
The control plane keeps memory policy separate from model reasoning. Admission rules decide what enters the Stash, retrieval rules decide what comes back, and conflict handling routes disagreements for review. This means the knowledge your agents rely on is admitted under explicit, inspectable rules rather than whatever a model happened to produce in the moment.
Review stays in the loop. When sources disagree, or when a claim goes stale and needs confirmation, the system surfaces the disagreement for people to resolve. Provenance and audit records make each decision traceable, so teams can review not just the current state of knowledge but the history of how it was admitted, changed, and corrected over time.
Mission Control gives teams a working view of the Stash itself. Browse and edit memories, manage sessions, import and export knowledge, and explore connections through the memory graph. This turns governance from an abstract policy into something operators can inspect and act on day to day.