Skip to main content

​
What is Shared Memory?

Shared Memory is like a team bulletin board for your digital twin. When someone adds information to Shared Memory, everyone using the same digital twin can benefit from it.
Simple way to think about it:
  • User Memory = Your personal notes (only you see them)
  • Shared Memory = Team notes (everyone sees them)

​
How It Works

​
Adding to Shared Memory

Any user can add information for the whole team:
Prompt
Remember for the team: All pull requests require two approvals before merging
The digital twin stores this, and now everyone on the team gets consistent guidance about code reviews.

​
Using Shared Memory

When someone asks a related question later, the digital twin automatically uses the shared information:
Prompt
How many approvals do I need for my pull request?
Response
According to your team's guidelines, all pull requests require two approvals before merging.

​
Real-World Examples

What to store:
  • Coding standards and style guides
  • Approved libraries and frameworks
  • Code review requirements
  • Deployment procedures
Example:
“Remember for the team: We use TypeScript for all new projects, React 18 for frontend, and require ESLint checks to pass before commits.”
Now every developer gets consistent guidance without having to repeat these standards.
What to store:
  • Style guide preferences
  • Template structures
  • Terminology standards
  • Brand voice guidelines
Example:
“Remember for the team: API documentation should always include authentication examples and use professional but friendly language.”
Every writer now produces consistent documentation.
What to store:
  • Common troubleshooting steps
  • Escalation procedures
  • Product knowledge
  • FAQ responses
Example:
“Remember for the team: For billing issues, always verify the customer’s last payment date and subscription tier before troubleshooting.”
All support agents follow the same process.
What to store:
  • Course policies
  • Grading rubrics
  • Resource lists
  • Institutional guidelines
Example:
“Remember for all users: Late assignments lose 10% per day, maximum 3 days late.”
All students and instructors get consistent policy information.

​
Shared Memory vs User Memory

AspectUser MemoryShared Memory
Who sees itOnly youEveryone on your team
What to storeYour preferences, your projectsTeam standards, shared knowledge
Example”I prefer concise responses""Our team uses TypeScript”
PersistenceFollows you across digital twinsStays with this digital twin
When there’s a conflict, your User Memory preferences typically take priority over Shared Memory—so you can still customize your experience while following team standards.

​
Managing Shared Memory

​
View What’s Stored

Ask your digital twin:
Prompt
Show me everything in shared memory
or search for specific topics:
Prompt
What coding standards are stored in shared memory?

​
Update Information

Prompt
Update the shared memory: Change our React version requirement to 18.2

​
Remove Outdated Information

Prompt
Remove the old deployment procedure from shared memory

​
Best Practices

1

Start with the essentials

Add your team’s most important standards first—things everyone needs to know.
2

Be specific

“Use TypeScript for new projects” is better than “Use good practices.”
3

Keep it current

Review shared memory periodically to remove outdated information.
4

Don't over-store

Only add information that truly benefits the whole team. Personal preferences belong in User Memory.

​
Storage Architecture

Shared Memory uses key-value storage organized by namespaces:
namespace/key_name → {
  value: "stored data",
  description: "purpose and context",
  created: timestamp,
  shared: true
}

​
Tool-Based Access

Reading shared memory:
get_from_memory("technical_stack", "true")  // Search by namespace
get_from_memory("typescript", "true")       // Search by keyword
get_from_memory("", "true")                 // Get all shared parameters
Writing to shared memory:
set_in_memory([
  {
    key_name: "primary_language",
    key_value: "TypeScript",
    key_description: "Primary language for all new projects",
    key_namespace: "technical_stack"
  }
], "true", "false")

​
Namespace Organization

Organize parameters into logical categories:
  • company_standards — Organization-wide policies
  • technical_stack — Approved technologies
  • compliance_rules — Regulatory requirements
  • documentation_standards — Writing conventions

​
Assistant Integration

Reference shared memory in Assistant instructions:
Before reviewing code:
1. Retrieve standards: get_from_memory("technical_stack", "true")
2. Check code against stored standards
3. Flag violations with specific references

​
Batch Operations

Store multiple parameters at once:
set_in_memory([
  {key_name: "lang", key_value: "TypeScript", key_namespace: "tech_stack"},
  {key_name: "framework", key_value: "React 18", key_namespace: "tech_stack"},
  {key_name: "testing", key_value: "Jest + RTL", key_namespace: "tech_stack"}
], "true", "false")