Muscle Memory App Overview
Muscle Memory stops your business from re-learning its own lessons — it distills what actually happened into durable, evidence-backed claims, then recalls them exactly when they matter.
What is the Muscle Memory App?
Frontline turnover quietly deletes operational knowledge. Which corrective action actually ended an incident cluster, which automation is safe to lean on, why deliveries moved to the side entrance — that knowledge lives in the head of whoever learned it, and it leaves when they do. Successors re-pay for it in repeated mistakes.
Muscle Memory watches closed operational arcs — an incident whose corrective action completed and whose recurrence window has fully elapsed, an automation that has run reliably for months or was rolled back — and distills each into a business memory: one claim, a confidence score, and links to the actual records it was learned from. Those lessons then surface inside Ask AI answers, on a browsable Business Memory tab, in global search, and on the dashboard.
Core Value Proposition:
- 🧠 Knowledge survives turnover — lessons are owned by the business, not by the person who learned them
- 🧾 Every memory shows its receipts — a claim without at least one linked evidence record is not stored (“no receipt, no memory”)
- 🎯 Recall at the moment of need — lessons are injected into Ask AI answers, so “why do we do it this way?” gets the real answer with links
- ⚖️ Self-correcting — confirmation strengthens a lesson; contradicting evidence decays it until it is marked superseded and drops out of answers
- 🔒 Operations, never dossiers — claims describe locations, patterns, and outcomes; people appear only behind permissioned evidence links
Key Concepts (How It Works)
If you only read one section, read this one — it explains the model behind the screens.
How business memory and personal memory differ
Muscle Memory owns two separate memory layers, backed by two separate tables, with opposite privacy rules. This is the distinction people get wrong most often.
| Business memory | Personal memory | |
|---|---|---|
| What it stores | Lessons the organization learned from operational outcomes | Durable facts the assistant remembers about you (what you were working on, stated preferences) |
| Who can see it | Every member the app is available to | Only you — no manager, admin, or coworker |
| Who writes it | Distillers (automatic) and managers/members adding lessons | Distilled from your own assistant conversations |
| Where you review it | Business Memory tab | Personal Memory tab |
| Who can erase it | Managers and admins (forget) | You, one fact at a time or all at once |
| Setting | recall_enabled, distiller toggles |
personal_memory_enabled |
Enabling the Muscle Memory app is the single consent moment for both layers; each layer then has its own setting inside the app. Turning personal memory off tenant-wide does not touch business memory, and vice versa.
What a business memory actually is
A business memory is one claim — a specific, falsifiable, operational sentence — plus:
- a domain (
safety_hub,scheduling,leave_management,automation, oroperations) - a confidence score between 0 and 1
- an optional scope (a location, when the lesson is site-specific)
- a source identifying which distiller (or a manager) produced it
- evidence links — polymorphic pointers to the real records behind the claim, each carrying a role (
incident,corrective_action,recurrence_window_incident,contradicting_incident)
Evidence is what makes a memory trustworthy rather than a rumor. Distilled memories always carry evidence. Manager-added lessons are the one exception: they may have no evidence rows because the author is the attestation — they are born verified instead.
What determines a lesson’s confidence
Confidence is not decorative — it decides whether a lesson is recalled at all. Four forces move it:
| Event | Effect |
|---|---|
| A manager confirms the lesson | +0.10 (capped at 1.0), and it is marked verified |
| A re-observed arc reinforces it | +0.05 (capped at 0.95), reinforcement count increments |
| A manager corrects it | No confidence change — the note is kept alongside the claim, and the lesson counts as human-reviewed |
| A contradicting incident appears | −0.10 per contradiction |
Two floors matter, and they are different things:
confidence_floor(a tenant setting, default 0.6) — the level below which a distiller will not mint a lesson at all, and below which a decaying lesson flips to superseded.- The recall floor (0.6, built into recall) — lessons below this are never pulled into an Ask AI answer, even though they remain visible on the Business Memory tab.
This is why a suggested lesson (born at 0.55) sits visibly in the review queue without shaping any AI answer until a manager confirms it — confirmation adds 0.10, lifting it to 0.65, above the floor.
What makes someone able to curate lessons
“Curate” means confirm, correct, forget, or add a lesson born verified. Two conditions must both hold:
- The user is an admin or above, or a manager (someone with the manager role in this business), and
- The Muscle Memory app is actually accessible to that user in this business.
That single predicate is shared by the web UI, the Ask AI agent tools, and the API, so no surface can gate differently from another.
Three other capability levels sit around it:
- Any member the app is published to can see every business lesson, use the “Ask about this” chip, and suggest a lesson (rate-limited to 5 per hour).
- Managers and above additionally see the Analytics tab.
- Admins (or an app admin for this app) additionally get the Settings tab and the sample-data controls. Managers deliberately do not get Settings — they curate lessons, but they don’t change what the distillers do.
How adding a lesson differs from suggesting one
Both use the same box on the Business Memory tab and the same underlying service. Who you are decides what happens:
| Manager or admin adds | Other member suggests | |
|---|---|---|
| Starting confidence | 0.8 | 0.55 |
| Verified at birth? | Yes — the author is the attestation | No — waits in the manager review queue |
| Feeds Ask AI answers immediately? | Yes | No (below the 0.6 recall floor) |
| Rate limit | None | 5 per hour |
| Notification | — | Managers and admins get an action request |
In both cases you type one plain sentence — there is no form to fill and no confirm step. A small AI call rewrites it into house style: a claim, a domain, and a location scope when a site is named. The save returns instantly and the rewrite happens in the background, so you are never waiting on the model. If the AI call fails, your raw sentence becomes the claim verbatim — your input is never lost.
Before anything is stored, the sentence is checked against the existing lessons using semantic search confirmed by a lexical similarity check. A near-duplicate reinforces the existing lesson instead of creating a copy. Text that looks like it contains a password, ID, or account number is rejected outright — never stored scrubbed.
Superseded vs forgotten — a lesson that stopped being true vs one a human removed
These two end-states look similar on screen and mean completely different things.
Superseded is automatic. When a lesson claims “incidents of this type at this location stopped after the corrective action,” and later incidents of that same type and location keep appearing, each one is linked as a contradiction and knocks 0.10 off the confidence. When confidence drops below your confidence_floor, the lesson flips to superseded: it stays visible with a badge, keeps all its receipts, and stops being recalled into AI answers. Managers get an action-request notification when the contradiction is recent. Nothing is deleted — the history survives.
Forgotten is a human act. A manager decides a lesson should go. Its status becomes forgotten; it disappears from every list and from recall, and the distillers will never re-mint it — the original dedup key stays on the record, so the arc that produced it is permanently claimed.
The list surfaces show active and superseded lessons together (a superseded claim still reads as a confident sentence, so hiding it would silently erase history while showing it unbadged would lie). Forgotten lessons are hidden. Recall uses active only.
What is automatic and what a human must do
| Automatic | Requires a person |
|---|---|
| Distilling closed arcs into lessons (nightly sweep) | Enabling the app (an admin opts in) |
| Retroactive backfill the moment the app is enabled | Confirming / correcting / forgetting a lesson |
| Reinforcing a lesson when an arc recurs | Adding or suggesting a lesson by hand |
| Decaying and superseding contradicted lessons | Changing distiller toggles and thresholds |
| Recalling relevant lessons into Ask AI answers | Loading or removing sample data |
| The Monday digest and the re-attestation nudge | — |
At a Glance
| 🧩 Memory layers | 🔬 Distillers | 🚪 Surfaces | 📱 Mobile |
|---|---|---|---|
| 2 (business + personal) | 3 (+ decay) | 8 | ✅ Read-mostly |
Perfect For:
- 🏭 Multi-site operations with frontline turnover — the incident distiller is scoped by incident type and location, so lessons stay site-specific and outlive the manager who learned them
- 🦺 Safety and compliance leads — the distiller records which corrective actions held and which did not, and alerts when one stops holding
- 🤖 Teams running automations — adopted-vs-rolled-back playbook history becomes a durable “is this safe to lean on?” answer
How It Works
The incident arc — from event to lesson
┌────────────────────────────────────────────────────────────────────────────┐
│ THE CLOSED OPERATIONAL ARC │
├────────────────────────────────────────────────────────────────────────────┤
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌───────────┐ │
│ │ INCIDENT │──▶ │ CORRECTIVE │──▶ │ RECURRENCE │──▶│ VERDICT │ │
│ │ logged │ │ ACTION │ │ WINDOW │ │ is final │ │
│ │ │ │ completed │ │ elapses │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ └─────┬─────┘ │
│ (60 days, config) │ │
│ ┌──────────────────────────────────────────┘ │
│ ▼ ▼ │
│ ┌─────────────┐ ┌──────────────┐ │
│ │ "HELD" │ │"DID NOT HOLD"│ │
│ │ no recurrence│ │ N recurrences│ │
│ └──────┬──────┘ └──────┬───────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────┐ ┌──────────────┐ │
│ │ MEMORY │ │ MEMORY + │ │
│ │ minted │ │ MANAGER ALERT│ │
│ └─────────────┘ └──────────────┘ │
└────────────────────────────────────────────────────────────────────────────┘
Knowing which fix did not work is as valuable as knowing which one did — so both verdicts become lessons, and the failed one raises an action request for managers when it is fresh.
The confidence lifecycle
┌────────────────────────────────────────────────────────────────────────────┐
│ CONFIRMATION ⟷ CONTRADICTION │
├────────────────────────────────────────────────────────────────────────────┤
│ │
│ manager confirms ─── +0.10 ──▶ ┌───────────┐ │
│ arc recurs ─── +0.05 ──▶ │ ACTIVE │ ◀── recalled in Ask AI │
│ │ lesson │ │
│ contradicting ─── −0.10 ──▶ └─────┬─────┘ │
│ incident │ │
│ │ confidence < confidence_floor │
│ ▼ │
│ ┌───────────┐ │
│ │SUPERSEDED │ ── still listed + badged │
│ │ │ ── out of Ask AI answers │
│ └───────────┘ ── receipts preserved │
│ │
│ manager forgets ──────────────▶ ┌───────────┐ ── hidden everywhere │
│ │ FORGOTTEN │ ── never re-learned │
│ └───────────┘ │
└────────────────────────────────────────────────────────────────────────────┘
Where lessons come from and where they go
SOURCES MUSCLE MEMORY CONSUMERS
┌────────────────┐ ┌──────────────────┐
│ Incidents + │──┐ ┌─▶│ Ask AI answers │
│ Corrective │ │ │ │ (with receipts) │
│ Actions │ │ ┌──────────────┐ │ └──────────────────┘
└────────────────┘ │ │ │ │ ┌──────────────────┐
┌────────────────┐ ├───────▶│ BUSINESS │────────┼─▶│ Business Memory │
│ Playbook runs │ │ │ MEMORY │ │ │ tab │
│ (automations) │──┤ │ │ │ └──────────────────┘
└────────────────┘ │ │ claim + │ │ ┌──────────────────┐
┌────────────────┐ │ │ confidence + │ ├─▶│ Global search │
│ Shifts + shift │ │ │ evidence │ │ └──────────────────┘
│ feedback (opt) │──┤ └──────────────┘ │ ┌──────────────────┐
└────────────────┘ │ ├─▶│ Dashboard widget │
┌────────────────┐ │ │ └──────────────────┘
│ Managers + │ │ │ ┌──────────────────┐
│ members (typed)│──┘ └─▶│ Weekly digest + │
└────────────────┘ │ Admin analytics │
└──────────────────┘
Key Features
🔬 Three distillers, plus a decay pass
Each distiller has its own on/off setting, so you choose what the business learns from.
| Distiller | What it watches | Default | Notes |
|---|---|---|---|
| Incident + corrective action | An incident’s corrective action completes and the recurrence window elapses | ✅ On | The crispest arc — the verdict is final, so the claim is stable. Records “held” and “did not hold” alike |
| Automation outcomes | Playbook run history: adopted (sustained runs, high completion rate) or rolled back (deactivated with recent failures) | ✅ On | Answers “is this automation safe to lean on?” |
| Staffing correlations | Staffing levels correlated against shift feedback for a location and weekday | ❌ Off | Experimental. No first-class “experiment” record exists, so it is the most false-positive-prone. Ships in shadow mode with a deliberately lower confidence cap, and it never claims causation |
| Contradiction decay | Later incidents of the same type and location that contradict a “this held” claim | Rides the incident toggle | Runs last in each pass, so a lesson minted from old history is immediately checked against what happened afterwards |
Use Case: Three different fixes were tried for a recurring slip hazard at one site. Muscle Memory remembers which one ended the cluster and which two did not — so the next site starts from the answer instead of the experiment.
💡 Pro Tip:
recurrence_window_daysis the patience dial. A shorter window means lessons appear sooner but with weaker evidence; a longer one means fewer, more trustworthy claims. It also defines what counts as a contradiction later.
✍️ Lessons a person adds
Plenty of operational knowledge never passes through an incident record — “deliveries go to the side entrance because the front ramp ices over.”
| Feature | Description |
|---|---|
| One sentence, no form | Type it on the Business Memory tab. Between 15 and 600 characters |
| AI structuring | Rewritten into a claim, assigned a domain, and scoped to a location when one is named — in the background, so the save is instant |
| Duplicate detection | Semantic search confirmed by lexical similarity; a near-duplicate reinforces the existing lesson rather than creating a copy |
| Sensitive-text rejection | Passwords, IDs, and account numbers are refused up front and never stored |
| Suggestions | Members who aren’t managers can suggest a lesson; it waits in the review queue, below the recall floor, and notifies managers |
| Never-lost input | If the AI call fails, your raw sentence is kept verbatim; if the lesson is rejected, your text is carried back into the box |
Use Case: A manager types “the walk-in freezer latch needs checking every Friday because the gasket ices up.” It becomes a scoped, domain-tagged, verified lesson — and every future “why do we check that?” gets the answer.
✅ The manager review loop
| Action | Effect |
|---|---|
| Confirm | Marks the lesson verified, records who confirmed it, and boosts confidence by 0.10 |
| Correct | Requires a note, which is kept alongside the claim permanently. Marks the lesson human-reviewed with no confidence boost |
| Forget | Status becomes forgotten. Leaves every list and recall, and the distillers will never re-mint it |
The Business Memory tab includes a review queue: filter by verification status and by domain, with the count and the truncation notice both honoring the filter so “Lessons (N)” is never misleading.
💡 Pro Tip: Use Correct rather than Forget when the story is more complicated than the claim. Correcting preserves the receipts and the note travels with the lesson; forgetting is permanent and unrecoverable by the distillers.
🔍 Recall inside Ask AI answers
When recall_enabled is on, every internal agent turn pulls the most relevant lessons into its prompt using semantic vector search, with a keyword fallback and a cross-domain second pass (a safety lesson often matters during a scheduling question). Recalled lessons are marked as referenced, which feeds the relevance ordering everywhere else.
Two guardrails:
- External-portal agents are excluded — candidate and former-employee assistants never see internal operational lessons.
- Answer provenance — answers that used lessons carry a footer listing them, each deep-linked to that lesson’s row on the Business Memory tab.
🧑💻 Personal Memory
The private half of the app. Durable facts the assistant keeps about you across sessions, grouped by domain, with:
- A Forget button on every fact and a Forget everything action in the page header
- A truncation-honest list (it discloses the total when more exist than are shown)
- A clear banner when personal memory has been switched off tenant-wide — existing facts remain visible and erasable, but nothing new is remembered
This page remains reachable at its stable privacy URL even for users the app isn’t available to, so previously stored facts can always be inspected and erased.
📊 Analytics & Insights
Standard analytics (Analytics tab, managers and above; the same numbers power the admin AI Analytics card and the dashboard widget, from a single shared source):
- Active lessons, verified vs unreviewed, minted in the last 30 days, average confidence
- Coverage by domain and formation by source (with friendly source names, not raw internal IDs)
- Counts of lessons forgotten by managers and lessons superseded by contradicting incidents
- The most-recalled lessons — what the business actually leans on
For tenants with no lessons yet, the tab shows a cheap, cached estimate of how many lessons a backfill would find in existing history.
🔗 Where Muscle Memory shows up
| Surface | What you get |
|---|---|
| Business Memory tab | The full list with claims, confidence, verification state, correction notes, evidence links, and status badges |
| Personal Memory tab | Your private facts, erasable individually or all at once |
| Analytics tab | The aggregate learning picture (managers and above) |
| Settings tab | The eight configuration keys and sample-data controls (admins) |
| Ask AI answers | Relevant lessons recalled into answers, with a provenance footer |
| Global search | A Business Memory section in results |
| Navigation shortcut | Search “business memory”, “lessons learned”, or “institutional memory” to jump straight to the app |
| Dashboard widget | Active lessons, lessons needing review, and recent mints — deep-linking to the review queue when any await verification |
| Admin › AI Analytics | The aggregate card for admins, with an activation nudge for tenants that haven’t enabled the app |
| Mobile | A read-mostly list at /m/apps/muscle-memory with confirm and forget inline for managers |
🤖 AI Agent
Muscle Memory ships an Ask AI agent (toggleable via agent_enabled):
- List lessons — filtered by verification status and domain
- Search lessons — “what have we learned about the delivery rush?”
- Memory stats — totals, verification mix, coverage by domain, most-recalled lessons
- Managers: add a lesson — state it in one sentence and the agent structures and deduplicates it
- Managers: confirm, correct, or forget a lesson by ID
The agent routes every write through the same services as the web UI, with the identical manager gate — so the agent and the UI can never disagree about who may curate. Sample lessons are excluded from every agent read, and forgetting through the agent is the same archive-style status flip, never a hard delete.
🔌 API
A REST surface mirrors the web and agent behavior exactly:
| Endpoint | Purpose |
|---|---|
GET /api/v1/muscle-memory/lessons |
List (paginated), filterable by status and domain; add q= for relevance search |
GET /api/v1/muscle-memory/lessons/:id |
One lesson with its evidence |
GET /api/v1/muscle-memory/stats |
The aggregate stats |
POST /api/v1/muscle-memory/lessons |
Manager adds a lesson |
POST /api/v1/muscle-memory/lessons/:id/verify |
Manager confirms |
POST /api/v1/muscle-memory/lessons/:id/correct |
Manager corrects, with a note |
DELETE /api/v1/muscle-memory/lessons/:id |
Manager forgets (archive-style — no hard delete exists) |
Sample lessons are excluded from every API read, matching recall.
🔔 Notifications
All five run under one notification category (“Business Memory Lessons”), in-app by default, controllable from the standard notification settings page.
| Notification | Trigger | Recipients |
|---|---|---|
| Weekly digest | Monday, when the business learned anything in the past 7 days | Managers, admins, super admins |
| Re-attestation nudge | Rides the digest: manager-added lessons nobody has re-confirmed or used in 6 months | Managers, admins, super admins |
| Backfill complete | The enablement backfill finished and found lessons | Admins and super admins |
| A corrective action didn’t hold | The distiller confirms a fix failed (only when the arc closed recently) | Managers, admins — as an action request |
| A lesson may no longer hold | Contradiction decay just superseded a lesson (only when the contradiction is recent) | Managers, admins — as an action request |
| A teammate suggested a lesson | A non-manager submits a suggestion | Managers, admins — as an action request |
Every alert deep-links to the specific lesson’s row, and the review-queue ones pre-apply the “needs review” filter.
User Roles & Permissions
| Action | Member | Manager | Admin |
|---|---|---|---|
| See business lessons (tab, mobile, global search, Ask AI recall) | ✅ | ✅ | ✅ |
| “Ask about this” — open Ask AI pre-seeded with a lesson | ✅ | ✅ | ✅ |
| See and erase your own personal memory | ✅ | ✅ | ✅ |
| Suggest a lesson (born unverified, 5/hour, awaits review) | ✅ | ✅ | ✅ |
| Add a lesson born verified | ❌ | ✅ | ✅ |
| Confirm / correct / forget a lesson | ❌ | ✅ | ✅ |
| Analytics tab | ❌ | ✅ | ✅ |
| “Automate this lesson” link | ❌ | ❌ | ✅ |
| Settings tab (distiller toggles, thresholds) | ❌ | ❌ | ✅ |
| Load / remove sample data | ❌ | ❌ | ✅ |
Transparency is deliberate: every member sees what the business has learned, because lessons describe operations — never people. The “Automate this lesson” link is admin-only because it lands on an admin-gated automations page — surfacing it to managers would bounce them.
Privacy
- Operations only, never people. Claims are built from structured fields — incident type, location name, dates, counts — plus a scrubbed snippet of the corrective action. Incident narratives are never used, and individuals are never named in claim text.
- Sensitive text is refused, not scrubbed. If a would-be claim trips the sensitive-data patterns (passwords, government IDs, account numbers), the lesson is skipped entirely rather than stored partially redacted.
- Evidence enforces source permissions. People and full records appear only behind evidence links, each of which resolves through the source app’s own permissions — a viewer who can’t open the underlying incident can’t read it through Muscle Memory either.
- Personal memory is strictly per-user. Scoped to your user and this business. No manager or admin can read your facts, and you can erase any or all of them at any time.
- Nothing is hard-deleted. Forget is an archive-style status flip everywhere — web, agent, and API alike.
Settings Reference
Eight keys, all on the Settings tab (admins only).
| Setting | Type | Default | Effect |
|---|---|---|---|
incident_distiller_enabled |
boolean | true |
Gates the incident + corrective-action distiller and the contradiction-decay pass |
personal_memory_enabled |
boolean | true |
Gates personal AI memory (per-user durable facts) |
automation_distiller_enabled |
boolean | true |
Gates the automation (playbook) outcomes distiller |
scheduling_distiller_enabled |
boolean | false |
Gates the experimental staffing/feedback correlation distiller |
recall_enabled |
boolean | true |
Gates business-memory recall inside Ask AI answers |
agent_enabled |
boolean | true |
Gates the Muscle Memory assistant in Ask AI |
confidence_floor |
number | 0.6 |
Minimum confidence to mint or keep a lesson; the supersede threshold for decay |
recurrence_window_days |
number | 60 |
How long the incident distiller waits before judging an arc — and the anchor for what later counts as a contradiction |
Getting Started
For Employees
- Open Muscle Memory from the Apps grid — you land on Business Memory
- Browse what the business has learned; use the domain filter to narrow it
- Tap Ask about this on any lesson to explore it in Ask AI
- Know something the lessons are missing? Type one sentence in the box to suggest it
- Visit the Personal Memory tab to see and erase what the assistant remembers about you
For Managers
- Open the Business Memory tab and filter to Needs review
- Confirm the lessons that are true, Correct the ones that need a note, Forget the ones that don’t belong
- Add the knowledge no system ever recorded — one sentence per lesson
- Watch the Analytics tab for coverage by domain and which lessons actually get used
- Act on the action-request notifications: a corrective action that didn’t hold, or a lesson that may no longer hold
For Administrators
- Enable Muscle Memory from the Apps Marketplace — this is the consent moment for both memory layers
- The retroactive backfill starts immediately; you’ll get a notification with what it found
- Review the Settings tab: leave the incident and automation distillers on, and consider the staffing correlation distiller only once you trust the crisp ones
- Tune
confidence_floorandrecurrence_window_daysto your operational tempo - Evaluating on an empty tenant? Load sample data from Settings — it mints realistic lessons across all sources so every surface renders
Best Practices
- ✅ Work the review queue weekly. The Monday digest exists for this. Unverified lessons sit at their minted confidence; a manager’s confirmation is what makes them authoritative.
- ✅ Correct rather than forget when the claim is incomplete — the note survives and the receipts stay attached.
- ✅ Treat “did not hold” lessons as the valuable ones. They tell the next site what to skip.
- ✅ Leave the staffing distiller off until you trust the others. It infers correlation from data that has no first-class record, which is why it ships off.
- ✅ Add the lessons no system can see. The distillers only know what got recorded; the tacit knowledge in a manager’s head has to be typed.
- ✅ Don’t raise
confidence_floorcasually. It gates minting and supersedes decaying lessons — raising it can silently retire lessons you’d rather keep and badge. - ✅ Re-attest manual lessons when nudged. Manager-added claims have no distiller re-checking them, which is exactly why the six-month prompt exists.
How We Compare
Muscle Memory sits in an unusual place: knowledge platforms store what people wrote down, while Muscle Memory distills what happened.
| Capability | MangoApps Workforce | Guru | Glean |
|---|---|---|---|
| Knowledge synthesized automatically from operational records (incidents, corrective actions, automation runs) | ✅ | ❌ | ❌ |
| Human verification state on each item (verified / unverified, with re-attestation prompts) | ✅ | ✅ | ❌ |
| Confidence score that decays on contradicting evidence | ✅ | ❌ | ❌ |
| Included in a broader workforce operations platform rather than a standalone subscription | ✅ | 💰 | 💰 |
| Legend: ✅ Included | ❌ Not Available | 💰 Separate paid product |
Guru and Glean are strong at what they do — Guru pairs authored cards with an SME verification workflow, Glean indexes and searches across your existing SaaS tools with permission-aware results. Neither creates new claims from operational outcome records, which is the specific job Muscle Memory does.
Why MangoApps Workforce?
- 🔗 Unified platform — Muscle Memory reads directly from Safety Hub incidents, automation playbook runs, and scheduling data already in the system, with no connector to configure
- 🧾 Evidence by construction — a claim without a linked record isn’t stored, so every lesson is auditable back to what actually happened
- 🤖 AI-native — lessons flow into every internal agent’s answers automatically, rather than sitting in a knowledge base someone has to remember to search
Frequently Asked Questions
Q: How is this different from the AI Memory page I already have?
A: It’s the same surface, and Muscle Memory now owns both halves of it. The personal section holds durable facts about what you were doing — private to each user and erasable anytime. The business section holds the organization’s distilled lessons: evidence-backed, visible to everyone the app is published to, and surviving turnover. The old /apps/ask-ai/memory URL still works and lands you on the app.
Q: Does it store information about individual employees?
A: No. Claims describe operations only — locations, patterns, processes, outcomes. Individuals are never named in claim text; they appear solely behind evidence links that enforce each source app’s own permissions.
Q: Who can see my personal memory?
A: Only you. It’s scoped to your user in this business — no manager, admin, or coworker can read it. You can review every fact on the Personal Memory tab and erase any or all of them at any time. An admin can switch personal memory off tenant-wide without touching business memory.
Q: Can I turn off recall without disabling the app?
A: Yes — switch recall_enabled off. Lessons stay browsable on the Business Memory tab and in search; agents just stop citing them.
Q: What happens when a manager forgets a lesson?
A: Its status becomes forgotten, it leaves every list and recall immediately, and the distillers will never re-mint it — the original dedup key stays on the record, so that arc is permanently claimed. Nothing is hard-deleted, so the row and its receipts survive for audit.
Q: Why does a lesson say “Superseded”?
A: Contradiction decay. The lesson claimed a corrective action stopped a type of incident at a location, but later incidents of that same type and location kept appearing. Each one knocked 0.10 off its confidence until it fell below your confidence floor. It stays listed with its receipts, but it no longer feeds Ask AI answers. Correct it if the story changed, or forget it.
Q: I’m not a manager — can I contribute a lesson?
A: Yes. Type it in the same box and it becomes a suggestion: it lands in the manager review queue at a confidence just below the recall floor, so it won’t shape AI answers until a manager confirms it. You can suggest up to five per hour.
Q: We just enabled it — will the page be empty?
A: No. Enabling the app triggers a retroactive backfill over your existing history (the distillers scan all data at rest, not just new events), and you’ll get a notification telling you how many lessons it found. If your tenant genuinely has no history yet, an admin can load sample data from Settings.
Related Resources
- Ask AI App Overview — where business lessons are recalled into answers
- Safety Hub App Overview — the incidents and corrective actions the primary distiller reads
- Mango Signal App Overview — the sibling intelligence layer for engagement signals
A business that remembers its own lessons stops paying for them twice.