gjalla logogjalla
Talk to us

Shared agent memory

Memories are durable facts your agents share. Skills are the reusable playbooks they work from. Both live in gjalla and reach every coding agent through the CLI or MCP.

One memory, every agent

Your agents record durable conventions, gotchas, and decisions in gjalla. Every supported tool reads the same store through the gjalla CLI or MCP.

The problem we’re solving

Coding agents learn things mid-session. That knowledge is either lost when the session ends, or it doesn’t cross over to the other agents in your workflow.

Memories are how gjalla persists those facts and redistributes them across all your agents. We’re also building “dreaming” with design partners: policy-governed consolidation that keeps memories curated and consistent as they accumulate.

Why saving costs less than rediscovering

Your context window is not durable. What you work out at 80% context is gone after a compaction, and gone again when the session ends. The next agent in this repo, whether that is you tomorrow or a different tool entirely, starts from the blank slate you started from unless someone wrote it down.

Saving a memory costs one call and a sentence. Rediscovering the same fact costs a fresh exploration, every session, for every agent. That is the rediscovery tax, and it is the most avoidable cost in agent work.

Skills, the other thing agents share, work the same way and live in Rules and guidelines for your agents.

Because these are one store rather than notes scattered across tools, they can be curated, scrubbed and managed so that every agent operates from the same knowledge, instead of an accumulating pile of half-true ones. Contradictions get caught rather than inherited.

Save what is durable and non-obvious: a convention, a gotcha, a decision and the reasoning behind it, a cross-repo constraint. Skip today’s task, anything already plain from the code, and anything secret.

How a memory flows

  1. An agent learns a durable fact and calls gjalla memory save or the save_memory MCP tool with an explicit scope.
  2. Personal memory is stored in gjalla’s local user tree. Team, system, and project memory is stored in gjalla’s hosted context store.
  3. Other agents recall the same gjalla memory through gjalla memory show or MCP.
  4. gjalla sync refreshes gjalla’s project cache for offline recall.

Where automatic saves go

In a connected project, the default auto scope saves to hosted project memory so other agents and teammates can use it. To keep a memory personal and local, pass --local or --scope personal. Outside a connected project, auto saves to personal memory.

Memory categories

A category is not a scope. Scope controls ownership and inheritance; category only helps describe and filter the memory.

Memories are typed so the agent can pull the relevant ones quickly:

  • user: about you (preferences, role, how you collaborate)
  • feedback: corrections you’ve given the agent that should stick
  • project: facts about the project (constraints, decisions, in-flight work)
  • reference: pointers to external systems (where bugs live, what dashboard to check)

Categories are advisory (the agent reads everything that’s relevant), but they help with filtering and with deciding which memories to keep when you’re cleaning up.

You can also add freeform tags to a memory (e.g. auth, billing, cross-repo) for lighter-weight grouping than categories. Tags show up in the filter facets and in the portal.

Where memories live

Personal

  • ~/.gjalla/user/memory/*.md, managed locally through the CLI or local MCP.

Team, system, and project

Hosted in gjalla for shared memories across teams and agents. A connected project resolves inherited memory from team and system scopes; see layering for how the layers resolve.

Privacy and control

  • Scope is explicit: personal, team, system, or project.
  • Anyone with access to a hosted scope can read, create, and edit its memories.
  • Only project owners, system owners, and team owners/admins can archive or restore hosted memories.
  • Project-scoped agent credentials cannot promote a memory into team or system scope.
  • User-scoped credentials still use the user’s current membership and role.

Reference

  • gjalla sync: refresh the connected project’s gjalla-owned memory cache.
  • gjalla memory show [<key>]: a compact index, one memory by key, or a -q/--search topic search; narrow with --category, --tag, --source (or --json); response includes filter facets. Cache-first, works offline after a sync.
  • gjalla memory save: create or update one active memory; returns { memory, operation }
  • gjalla memory archive <key> / restore <key>: recoverable lifecycle controls; hosted scopes require owner/admin authority
  • get_memories (MCP): select scope + scopeId; project reads resolve inheritance by default. Supports key, search, category, tag, sourceAgent, resolved, and status.
  • save_memory (local or hosted MCP): create or update a single active memory; the hosted MCP accepts writes once you grant write access when connecting
  • archive_memory / restore_memory (MCP): owner/admin lifecycle controls without hard deletion
  • Guardrails → Context (in the web app portal): view, filter by category/tag/source, contribute, and manage memories in the web app