> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praxis-ai.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Shared Memory
> Information that your digital twin shares with all users in your organization—like a team knowledge base everyone can access.
## 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:
```text Prompt wrap icon="comment" theme={null}
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:
```text Prompt wrap icon="comment" theme={null}
How many approvals do I need for my pull request?
```
```text Response wrap icon="robot" theme={null}
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
| Aspect | User Memory | Shared Memory |
| ----------------- | -------------------------------- | -------------------------------- |
| **Who sees it** | Only you | Everyone on your team |
| **What to store** | Your preferences, your projects | Team standards, shared knowledge |
| **Example** | "I prefer concise responses" | "Our team uses TypeScript" |
| **Persistence** | Follows you across digital twins | Stays 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.
***
## Who can edit what
Every shared entry records **who added it**. You can always edit or delete the shared entries you authored yourself; editing or removing entries added by **other** members requires edit rights on the Digital Twin (typically an admin). Personal memories that were never created inside the twin can't be turned into shared ones.
You can also manage shared entries outside of chat: open the **Memory panel** (My Profile → Memory, or sidebar → Settings → Personal → Memory Parameters) to browse, search, share/unshare, edit, and delete entries directly.
***
## Managing Shared Memory
### View What's Stored
Ask your digital twin:
```text Prompt wrap icon="comment" theme={null}
Show me everything in shared memory
```
or search for specific topics:
```text Prompt wrap icon="comment" theme={null}
What coding standards are stored in shared memory?
```
### Update Information
```text Prompt wrap icon="comment" theme={null}
Update the shared memory: Change our React version requirement to 18.2
```
### Remove Outdated Information
```text Prompt wrap icon="comment" theme={null}
Remove the old deployment procedure from shared memory
```
***
## Best Practices
Add your team's most important standards first—things everyone needs to know.
"Use TypeScript for new projects" is better than "Use good practices."
Review shared memory periodically to remove outdated information.
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:
```javascript wrap theme={null}
namespace/key_name → {
value: "stored data",
description: "purpose and context",
created: timestamp,
shared: true
}
```
### Tool-Based Access
**Reading shared memory:**
```javascript wrap theme={null}
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:**
```javascript wrap theme={null}
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:
```markdown wrap theme={null}
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:
```javascript wrap theme={null}
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")
```