skills.rest
letta-ai
letta-aiOFFICIAL
Explore all skills by this author →
Website𝕏@letta_aiGitHub

managing-shared-memory

Create and manage git-tracked shared memory repositories attached to multiple Letta agents.

3.2k|385|Updated Oct 25, 2025
Search Tags:#Git#shared memory#Repository#Collaboration#Letta#memfs#Multi-Agent
One-click install
npx skills add https://github.com/letta-ai/letta-code --skill managing-shared-memory
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: managing-shared-memory
Source: https://github.com/letta-ai/letta-code/tree/main/src/skills/builtin/managing-shared-memory
Command: npx skills add https://github.com/letta-ai/letta-code --skill managing-shared-memory

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Agents often need to share context, files, and datasets that do not belong in any single agent's own memory. This Skill lets you create shared memory repositories hosted on Letta Cloud, attach them to one or more agents, and work with them as ordinary git checkouts on disk.

Core Features & Use Cases

  • Repository Lifecycle Management: Create, list, attach, and detach shared memory repositories using the letta shared-memory CLI subcommand.
  • Git-Based File Workflows: Read, edit, commit, and inspect history in attached repositories with standard git commands; the harness pushes clean commits after each turn.
  • Mount Repair and Sync: Recover missing or broken mounts with letta shared-memory sync and resolve push conflicts with rebase-based retries.
  • Use Case: Two agents collaborating on a research project attach the same shared-notes repository; one agent commits a dataset while the other pulls the changes with git pull --rebase and continues analysis.

Quick Start

Ask your agent to create a shared memory repository named shared-notes and attach it so both agents can read and write the same files.

Frequently Asked Questions about managing-shared-memory

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I share memory between multiple Letta agents?▼

Create a shared memory repository with `letta shared-memory create --name <name>`, then attach it to each agent with `letta shared-memory attach <name>`. Each agent gets its own git checkout mounted next to its memory directory, and committed changes are pushed after each turn.

How do I commit files to a shared memory repository?▼

Edit files in the mounted checkout at $MEMORY_DIR/../<repo-name>, then run git add and git commit as usual. The harness pushes clean commits from read/write attached repositories after the turn, retrying once with a rebase if another agent pushed first.

Why is my attached shared memory repository missing on disk?▼

The repository was attached without materializing the local mount, often because it was attached from another surface while your session was running. Run `letta shared-memory sync` to clone or pull every attached repository and restore the mount.

What happens when two agents push conflicting changes to shared memory?▼

If a push is rejected because another agent pushed first, the harness pulls with rebase and retries once. Dirty files and unresolved conflicts are left untouched; resolve the conflict, finish the rebase or commit, and the harness retries the push after a future turn.

Does writing to shared memory update my agent's in-context memory?▼

No. Shared memory is not part of the system prompt, so writing to it does not change in-context memory. To change what the agent sees in context, edit its memory blocks or MemFS files instead.

Related Skills

Explore More Software Engineering Skills→
quitgeniusquitgenius

sparky

Communicate with a persistent Letta AI agent for task delegation and information retrieval.

Official
Intermediate
githubnextgithubnext
5.1k

agent-collaboration

Standardizes worktree awareness, decision recording, and cross-agent communication patterns for squad agents.

Official
Basic
JHostalekJHostalek
10

rebase

Rebase a Git branch onto a target branch and resolve conflicts.

Community
Advanced
Kastalien-ResearchKastalien-Research

defragmenting-memory

Decompose large memory blocks into hierarchical single-purpose components with YAML metadata.

Official
Advanced