Shelby Memory Agents
AI Agent Memory
Durable, scoped AI agent memory for production workflows.
Enrich every recurring AI workflow with a durable or permanent memory identity that retrieves the right context before each run and learns from outcomes.
Starts at $10 per agent per month with unlimited stored memory records.
- OpenAI-compatible API
- Scoped retrieval filters
- Structured write-back
Summary capsule
Shelby Memory Agents are Achiral's AI agent memory product: memory at the level agents actually work, customer accounts, projects, deployments, tasks, and recurring workflows. Each agent maintains its own durable, bounded memory, so your AI can continue from prior decisions, preferences, and outcomes without mixing unrelated context. Learn more about Achiral's Emergent Memory System and Shelby Memory Agents.
Where it fits
AI agent memory scoped to the work, not the human seat
Most AI tools remember conversations by user. Shelby remembers the work itself: the account, project, workflow, or agent that needs continuity no matter who asks next.
Without Shelby
Every request starts too fresh.
Bob asks an AI assistant to prepare a rollout review. It answers from the prompt and current docs. A month later, Stacy asks about the same rollout, but unless someone restates the prior blockers, owners, exceptions, and decisions, the assistant has to rediscover them.
With Shelby
The workflow keeps its own history.
The release-readiness agent has a scoped memory identity. It remembers that SSO mapping blocked the last rollout, staged releases require admin review, and Dana owns the approval path. When Stacy asks, the agent starts from that history automatically.
Recurring operations agents that remember prior runs, exceptions, owners, approvals, and handoff notes.
AI SaaS copilots that keep one account's preferences, decisions, and working context separate from every other account.
Implementation agents that carry rollout state, integration choices, and environment configuration from one session to the next.
Developer agents that retain repo conventions, product history, prior review notes, and team-specific decisions.
The primitive
Durable AI agent memory: one workflow, one identity
Shelby Memory Agents let one AI workflow carry its own memory forward. Run a task with the prior decisions, exceptions, owners, preferences, and handoff notes that belong to that scope. They extend Achiral's broader AI memory platform with a product surface for scoped autonomous workflows.
Durable identity
Assign a durable memory identity to your agent for any task, project, automation, or workflow.
OpenAI-compatible memory API
Call a chat endpoint your client already understands by path or request header, with a model of your choice.
Retrieval boundary
Resolve context with explicit limits on agent access over account, workspace, project, and other workflow filters.
Memory isolation
Isolate agent memory from org-wide Chiro memory with agent, account, project, or workflow-level scoping.
Memory loop
How AI agent memory works on every run
Operations agents, implementation agents, developer agents, and vertical copilots all need the same primitive: start with the useful history of the work, retrieve it safely, and update memory after the run. See the broader business use cases and the ACT-R versus agent memory concept guide for how this differs from ordinary retrieval.
01
Create a memory identity
Provision one durable memory identity for a task, account, workspace, project, or deployment before it starts running real work.
02
Retrieve the right context
Each call resolves the organization, token, agent, scope, and workflow hints before memory is assembled.
03
Run through your model stack
Use Achiral's inference layer or your own model endpoint while keeping memory policy outside prompt glue.
04
Write back what mattered
Persist outcomes, decisions, preferences, summaries, and handoff notes so the next run starts with useful history.
Developer interface
OpenAI-compatible AI agent memory API
Keep the integration simple for product teams: pass the agent in a header or path, call the chat endpoint your client already understands, and write back structured outcomes instead of treating every prompt as memory. For implementation details, review the technical architecture and the agent API guide.
Runtime
curl https://api.achiral.ai/v1/chat/completions \
-H "Authorization: Bearer acm_..." \
-H "X-Achiral-Agent: release-readiness-agent" \
-H "X-Achiral-Workflow: payments-migration" \
-d '{
"model": "chiro",
"messages": [
{
"role": "user",
"content": "Prepare the next rollout review with prior migration context."
}
]
}'Report write-back
POST /api/organizations/{orgId}/agents/{agentId}/sessions/{sessionId}/memory
Idempotency-Key: rollout-review-2026-07-10-001
{
"summary": "The workflow is blocked on SSO mapping and needs review by Friday.",
"memories": [
{
"kind": "workflow_preference",
"text": "Use staged rollouts with admin review before broad enablement.",
"confidence": 0.91
}
]
}Production controls
Scoped AI agent memory with production boundaries
Memory Agents are designed to fit into Achiral's existing production service, not sit beside it as a pilot exception. Identity, memory, billing, and egress controls are explicit from day one. Compare this model with other AI memory providersand review Achiral's security posture.
Agent and scope filters are applied before retrieval, not after.
Workflow hints narrow scope; they never widen it.
Shared learning is opt-in and promoted intentionally.
Lifecycle states control runtime access, auditability, and billing exposure.
Agent-bound tokens
New tokens default to one agent so a leaked credential cannot cross workflow boundaries.
Safe upstream routing
External endpoints are checked for unsafe DNS, redirects, private IPs, and repeated failures.
Operational guardrails
Rate limits, payload caps, SLO dashboards, and runbooks protect the runtime as usage grows.
Questions
AI agent memory FAQs
These answers help teams decide when to use an agent-specific memory identity instead of broad organizational context, prompt history, or a generic vector store. For pricing details, see Achiral pricing.
What is AI agent memory?
AI agent memory is durable, scoped state that an autonomous agent can retrieve before a run and update afterward. Unlike chat history tied to a human seat, agent memory follows the work: the account, project, workflow, or task, so the next run continues from prior decisions and outcomes.
What are Memory Agents?
Memory Agents (Shelby) are durable, scoped memory identities for AI agents and recurring workflows. Each agent retrieves relevant history before a run, preserves useful outcomes afterward, and continues work across runs without relying on prompt stuffing.
How are Memory Agents different from shared organizational memory?
Shared organizational memory helps a company remember broadly across people, tools, and decisions. Memory Agents narrow that memory to a specific agent, account, project, workflow, or task so autonomous systems can operate with the right context and clear boundaries.
What does workflow-scoped memory mean?
Workflow-scoped memory means retrieval and write-back are filtered by the job the agent is doing. A release-readiness agent, support copilot, or implementation agent can remember the history that belongs to that workflow without widening access to unrelated context.
How do Memory Agents work through the API?
Teams call an OpenAI-compatible API with an Achiral agent identity and optional workflow hints. Achiral resolves the agent, applies scope boundaries, retrieves memory, runs the request, and writes back structured outcomes after the task completes.
When should a team use AI agent memory?
Use AI agent memory when a system performs repeatable work and needs continuity: operations reviews, account copilots, implementation workflows, developer agents, renewal workflows, or product agents that must remember prior decisions and exceptions.
Start with one workflow
Give every recurring agent memory it can trust
Memory Agents bridge Achiral's shared organizational memory and the headless systems that run your work. Start with one task or workflow, prove the memory loop, then expand agent by agent.