ibl.ai Agentic AI Blog

Insights on building and deploying agentic AI systems. Our blog covers AI agent architectures, LLM infrastructure, MCP servers, enterprise deployment strategies, and real-world implementation guides. Whether you are a developer building AI agents, a CTO evaluating agentic platforms, or a technical leader driving AI adoption, you will find practical guidance here.

Topics We Cover

Featured Research and Reports

We analyze key research from leading institutions and labs including Google DeepMind, Anthropic, OpenAI, Meta AI, McKinsey, and the World Economic Forum. Our content includes detailed analysis of reports on AI agents, foundation models, and enterprise AI strategy.

For Technical Leaders

CTOs, engineering leads, and AI architects turn to our blog for guidance on agent orchestration, model evaluation, infrastructure planning, and building production-ready AI systems. We provide frameworks for responsible AI deployment that balance capability with safety and reliability.

Back to Blog

Agent Memory: What Memento and Sugar Glider Actually Solve

Miguel AmigotNovember 19, 2026
Premium

Memento and i14's Sugar Glider are both pitched as fixing AI memory, but they fix different things: Sugar Glider makes a long context cheap to hold, Memento lets an agent learn from stored experience. Neither decides who owns what an agent remembers between sessions.

The Short Answer

Neither i14's Sugar Glider nor the Memento framework alone stops an AI agent forgetting between sessions, because "AI memory" names three things: the context a model holds while it works, the experience an agent learns from, and the facts it keeps about people. Sugar Glider makes the first cheaper; Memento makes the second learnable. On ibl.ai the third can live in your own deployment, where you own all the code and the data.

Both projects are real and both results are worth knowing. But the claims circulating about them run ahead of what their own authors published, and the gap matters to anyone buying agents.

This post sorts the three kinds of memory, says what each project actually measured, and ends with the question neither of them answers: who holds what an agent remembers.

What does "AI agent memory" mean, and why does it cover three different problems?

"AI agent memory" is used for three layers that sit in different places and fail in different ways. Mixing them up is how a model-architecture paper gets described as fixing an agent that forgets your name overnight.

Layer Where it lives When it ends Example
Working memory (the context) GPU memory, inside the model while it runs When the request or session ends i14 Sugar Glider: fixed-size state up to 1M tokens
Experience memory An external store of past attempts and outcomes When someone deletes the store Memento: a Case Bank of successful and failed trajectories
Persistent memory about people and the organization A database the platform reads into each conversation When the owner of the database deletes it ibl.ai: per-person memories plus agent-wide shared memory

Only the second and third layers survive between sessions. The first is what makes a single long session affordable, which is valuable, but it is not recall.

What does i14's Sugar Glider actually claim about AI memory?

Sugar Glider is a family of language models from i14, a University of Melbourne spinout with offices in Melbourne and San Francisco. i14 announced Sugar Glider 120B on October 20, 2026.

The problem it targets is the transformer's key-value cache. Every attention layer stores keys and values for every earlier token, so memory grows with each token read, and the hardware caps how long a context can be and how many requests a server holds.

Sugar Glider replaces that with memory of a fixed size. Per i14's whitepaper, memory and compute per token are constant in the length of the context, and the models are built on NVIDIA Nemotron 3 Nano 4B and Nemotron 3 Super 120B-A12B.

The headline numbers, all from i14's own whitepaper:

Million-token requests held at once Nemotron 3 Super Sugar Glider-120B Ratio
One server, four H200 GPUs 14 453 32Γ—
One server, four H100 GPUs 2 73 36Γ—

Both counts use Sugar Glider's default memory setting. At four times that memory, the setting i14 uses for its best 128k recall, the 120B model fits 141 on the H200 server, ten times its parent.

i14 also reports that Sugar Glider-120B matches its parent on knowledge, code, reasoning and mathematics benchmarks, and scores 95.7 against the parent's 96.3 on RULER at 32k tokens.

An earlier i14 model shows the same idea at small scale. AWS's write-up of i14's Laplace 3B on Trainium2 gives a recurrent state of 29.5 MB per sequence, independent of context length.

Did i14 solve AI's memory problem with Sugar Glider?

i14 solved a specific, expensive part of it, and the version circulating on social media overstates the rest. Three corrections, each checked against i14's own whitepaper.

One million tokens, not one billion. The whitepaper's title says the models "read a million tokens", and every benchmark in it stops at 1M. We found no i14 claim about a billion-token context.

"100% retrieval accuracy" comes from narrow needle tests. The whitepaper says the small Sugar Glider-4B answers every single-needle question, and finds every needle hidden among distractor needles, from 32k to 1M tokens.

On the full 13-task RULER at 1M, Sugar Glider-120B scores 73.3, which i14 calls the strongest result for any constant-memory model.

It is a vendor whitepaper. The figures are i14's own measurements against its own parent model, not an independent replication. The AWS write-up on i14's Laplace 3B carries a similar caveat for that model: it says it does not measure retrieval quality at longer context lengths.

None of that makes the result small. Thirty-two times the concurrent long-context requests on the same server is a real cost lever for anyone running agents on their own GPUs. It just is not agent memory between sessions.

What is Memento, and how does it let an AI agent learn without fine-tuning?

Memento is a research framework published on arXiv on August 22, 2025, in a paper titled Memento: Fine-tuning LLM Agents without Fine-tuning LLMs by Huichi Zhou and ten co-authors. It is about 15 months old, not new.

The idea is case-based reasoning. The agent keeps an external episodic memory, a Case Bank, that records past task trajectories and whether each one succeeded or failed. For a new task, a planner retrieves the most relevant cases and uses them to guide the plan.

The language model's weights never change. Learning happens by writing new cases into the memory and, in one variant, training a neural retrieval model that picks which cases to use. The Memento code is on GitHub under the MIT license.

The paper reports top-1 on GAIA validation at 87.88% Pass@3 and 79.40% on the GAIA test set, plus 66.6% F1 and 80.4% PM on the DeepResearcher dataset. Case-based memory added 4.7 to 9.6 absolute points on out-of-distribution tasks.

Does Memento stop an AI agent forgetting everything between sessions?

Memento gives an agent a memory of how past tasks went, and that memory persists for as long as the Case Bank does. That is genuinely between-session learning, achieved without retraining the model.

But it is memory of procedure: which plans worked and which failed. It is not the record of who a person is, what they asked last week, or which policy the organization wants every answer to follow. Those are facts, and they need a store built for facts.

The other limit sits in a line common in agent-memory commentary: "the memory is the moat." If the memory is the valuable part, the deciding question is whose infrastructure holds it.

Who owns an AI agent's memory once it persists between sessions?

An AI agent's memory belongs to whoever owns the database it is written to, not to the model that reads it. We made that case in detail in who owns an AI agent's memory when you switch models.

Cohere, Meta, Couchbase, Databricks and GitHub each shipped agent memory between October 5 and October 28, 2026, covered in October 2026's agent memory launches. They differ sharply on export and deletion.

Both projects in this post make memory more valuable. Sugar Glider makes long working context cheap enough to use routinely; Memento shows stored experience can lift benchmark scores without touching the model.

The more an agent's memory is worth, the more it costs to leave it behind.

How does ibl.ai handle AI agent memory?

ibl.ai handles persistent memory as data the platform stores and injects, which on a self-hosted deployment sits in the customer's own infrastructure. Per the ibl.ai memory documentation, each agent has a Long-term Memory switch and two stores.

Personal memories are details the agent learned about one person, captured from conversations by a background job or added by hand, filed by category, and editable or deletable per person.

Shared memory is facts, rules and background every person who talks to the agent receives. It is only ever written by hand, so nothing one person says in a chat can reach everyone else.

Three switches cascade: the organization, the agent and the individual can each turn memory off, and Incognito conversations never store memory.

On each message the platform retrieves the most relevant personal memories and adds them, with shared memory, to the system prompt.

Because ibl.ai is model-agnostic and memory reaches the model through the system prompt, the memory store is separate from the model. Switch the model and the stored memories stay where they are.

What should a buyer ask about AI agent memory before turning it on?

Ask which of the three layers a vendor means. A claim about a longer or cheaper context is a model and infrastructure question; a claim about an agent that learns or remembers is a data question, and data questions have owners.

Then ask four things about the persistent layer:

  • Where is it stored, and can it run inside your network?
  • Who can read, correct and delete a memory about a specific person?
  • Can memory be switched off at the organization, agent and individual level?
  • What happens to it when you change models or leave the vendor?

On ibl.ai the answers come from the deployment itself, because you own all the code and the data. The memory your agents build is an asset of your organization, not a feature you rent.

Why does owning the AI stack matter?

ibl.ai is the agentic AI platform where you own all the code and the data. You self-host the entire stack inside your own perimeter, run it model-agnostic across any LLM and switch anytime, and pay by usage with no per-seat pricing β€” so you can deploy anywhere: your cloud, on-premise, GovCloud, or fully air-gapped.

  • You own all the code and the data

    Full source code under a perpetual license, running on your infrastructure. Not API access to someone else's platform β€” the stack itself is yours.

  • Model-agnostic

    Run any LLM β€” Claude, GPT, Gemini, Llama, Command, or your own fine-tune β€” and switch providers without rewriting the platform.

  • No per-seat pricing

    Usage-based billing against a budget cap you set. Cost tracks what your organization actually uses, not how many people you employ.

  • Deploy anywhere

    Your cloud, your VPC, on-premise, GovCloud, or a fully air-gapped network with no outbound connectivity.

1.6M+ users across 400+ organizations run the platform this way, including NVIDIA, MIT, and Syracuse University.

ibl.ai is family-owned and operated from New York, NY β€” a U.S.-headquartered, domestically-owned long-term partner, not a vendor that sells licenses and moves on.

Related Articles

GLM-5.3-Flash: Why a 4.44x Smaller KV Cache Changes Self-Hosting

Zhipu confirmed the anonymous 'Ox Alpha' model was GLM-5.3-Flash and released the weights: 320B total, 18B active, tying Claude Opus 4.8 on the Artificial Analysis index. The headline is the benchmark, but the number that matters for anyone self-hosting is the 4.44x KV-cache reduction β€” because KV cache, not parameter count, is what caps concurrent users per GPU.

ibl.aiAugust 27, 2026

Self-Hosted AI Agents for Healthcare: PHI Never Leaves

The best self-hosted AI platform for a hospital runs AI agents inside the HIPAA-covered network so PHI never leaves. What Ollama, vLLM, llama.cpp, Open WebUI, BioMistral and ClinicalBERT each are, what a hospital still has to add, the agents, the cost math, and why owning the stack is the defensible posture.

Mikel AmigotJune 8, 2026

AI Agent Audit Trails and RBAC: Five Platforms Compared

Which AI governance platforms give AI agents an audit trail and role-based access control? A side-by-side read of the vendor documentation for AWS Bedrock AgentCore, Microsoft Entra Agent ID, Google Cloud Agent Identity, LangSmith and ibl.ai: what each one logs, which plan or setting turns it on, and whose infrastructure holds the record.

Miguel AmigotNovember 19, 2026

AI Agents Outrun Static Credentials: Gartner and the FBI

In four weeks Gartner named AI agent identity a 2027 trend and predicted 25% of enterprise breaches will trace to AI agent abuse by 2028, HashiCorp shipped agent identity tooling, and the FBI described an agentic attack framework reaching privileged access in under three hours. The common thread is the static credential.

Miguel AmigotNovember 19, 2026

See the ibl.ai AI Operating System in Action

Discover how leading universities and organizations are transforming education with the ibl.ai AI Operating System. Explore real-world implementations from Harvard, MIT, Stanford, and users from 400+ institutions worldwide.

View Case Studies
Work with our team

Pilots, deployment, and full ownership

Every engagement is scoped to the work: you integrate ibl.ai with your own data, deploy it on your own infrastructure, and the engineering hours scale with the scope β€” so the price tracks the scope, not your headcount. Most customers keep us on afterwards for platform updates, new agents and integrations, and ongoing services.

Start here

Pilot

from $15K

fixed scope Β· fixed timeline

A time-boxed proof of value on your real data β€” not a slide deck.

Best for: Teams that want to see ibl.ai working before committing.

  • Deployed on your infrastructure or our cloud
  • 1–2 production agents wired to a slice of your data
  • One integration (LMS / SIS / SSO / data source)
  • Weekly working sessions with our engineers
  • Pilot fee credits toward a full engagement
Scope a pilot
Most common

Integration & Deployment

$25K – $80K

one-time fee Β· scoped to the work

Full deployment integrated with your data and systems. Engineering hours scale with scope.

Best for: Organizations rolling ibl.ai out across a department, campus, or business unit.

  • Platform deployed in your VPC, on-prem, or air-gapped
  • Integrated with your data + identity (SSO / SAML)
  • Multiple custom agents built to your workflows
  • Engineering hours proportional to scope
  • You own the data Β· run any LLM you choose
Plan a deployment
Full ownership

Codebase Transfer + Custom AI Engineering

Custom quote

perpetual license Β· you own the stack

We transfer the full source code. You own and self-host the entire platform β€” outright.

Best for: Organizations and enterprises that benefit from perpetual ownership and sovereignty.

  • Complete source-code transfer + perpetual license
  • Dedicated AI engineering team on your roadmap
  • Custom agents, models, and integrations to spec
  • Air-gapped capable Β· zero vendor lock-in
  • Family-owned, New York–based long-term partner
Talk about ownership
You own the code and data Run any LLM β€” Claude, GPT, Gemini, Llama Family-owned & operated from New York, NY