Most AI products are one surface: a chat box that calls a model. Useful for one-shot questions, weak at running anything ongoing. Cruma is five surfaces around one workspace brain — each one shaped for a specific kind of work, all of them sharing the same memory, the same procedures, and the same boundaries.
This page introduces them. The deeper "why is the substrate different" piece lives at /architecture. This one is just what each piece is and what it does.
A Space is how a real function works, not a folder.
The folder model — Drive, Notion, even Slack channels — is built on a flat idea: throw stuff in, hope it's there when you need it. Spaces flip it. A Space is a function of your business pre-organized as a working system — its records, its sessions, its memory, its procedures, all in one place, with the same shell on top.
You don't create a Space the way you'd create a folder. Cruma ships Spaces shaped like the work they're for: an Executive Strategy Space, an R&D Space, a Manufacturing Space, a Logistics Space, a Customer Success Space. Each one comes pre-loaded with the tables, the briefings, the workflows, and the procedures that function actually uses. You can still author your own, but the default isn't a blank canvas — it's a working surface that already understands the work.
What lives in a Space
- Records — typed tables (Projects, Tasks, Accounts, Drafts, anything the function tracks). Each row is queryable by the agent without you uploading anything.
- Sessions — chats with the agent, scoped to this Space. Tomorrow's session knows what last week's session decided.
- Memory — observations, decisions, and lessons distilled from those sessions. Scoped to this Space, so Executive Strategy doesn't bleed into Engineering.
- Workflows — scheduled, signal-fired, or manually-triggered automations that live in this Space's lane.
- Procedures — SOPs in plain English. The agent reads them before acting. You can change them in one place and every future run picks up the new version.
Why this shape matters
When an agent boots up inside a Space, it doesn't have to guess what it's looking at. The Space tells it: this is exec strategy, these are the relevant tables, here's what's been decided, here's how we do this kind of work. No "let me upload some context" dance. The context is the substrate.
And because every Space is shaped this way — same five ingredients, same shell — the agent operates the same way in every function. The skill pack changes; the operating model doesn't.
What it is
A function pre-organized as a working system: records + sessions + memory + workflows + procedures.
Where you find it
Left sidebar of the cockpit. Click any Space to enter; switch with one keystroke.
What's different
Notion gives you a blank page. Cruma gives you the system the page would be inside of, already shaped to the work.
Memory that knows who's asking — and what they can see.
Other AI memory tools are simple: one workspace, one shared memory, anyone with access sees everything. That's fine for a solo founder. It falls apart the moment a workspace has more than one person — because the things your CEO needs the agent to remember are not the things your engineer should hear about.
Cruma's Brain is built around the assumption that some memory is universal, some is per-team, some is per-person. Every observation, every session summary, every lesson carries a Space and a visibility tier — and the agent's response changes based on who's asking.
How the boundaries actually work
- Space scope — A lesson learned in Product is invisible to the Engineering Space's brain prefix. A customer-decision memory in Customer Success doesn't bleed into Marketing. The brain reads only the active Space (and workspace-wide trunk knowledge that's safe for everyone).
- Visibility tier — Three levels: workspace (the team), leadership (owner + admin only), user (the author alone). Sensitive things — pricing strategy, hiring deliberations, a customer in trouble — get the right tier when they're written.
- Who's asking — The same question from a CEO and a new hire returns different memory. Not because the agent decides to lie. Because the SQL filter that pulls memory knows the asker's role and identity.
What this looks like in practice
The CEO asks the agent "what's our pricing floor for Tier-2?" and gets the full decision thread — the call, the context, the settled rationale. A new hire asks the same thing five minutes later and the agent says "nothing in the sessions I can see." No policy file, no permissions UI to remember to configure — just the brain honoring the boundary that was already there.
The same question, asked from two accounts in the same workspace, returns two different answers. That's not a feature you turn on. That's how the brain is built.
What the Brain holds
- Observations — distilled facts the agent extracted from sessions, emails, calls, or documents. Each carries source attribution back to the original message.
- Session summaries — what each chat actually decided or accomplished, in two to four sentences. So a fresh session starts already up-to-date.
- Decisions — point-in-time choices with rationale. Stops the agent from re-litigating settled questions.
- Lessons — what was learned from a failure or surprise. The agent reads them before acting in the same situation again.
- Procedures — how you do the work. SOPs the agent honors verbatim until you change them.
What it is
Per-workspace memory layer that reads what each member can see, not just what the workspace knows.
Where it lives
Postgres + a vector index. Encrypted at rest. Renders into every prompt the agent runs.
What's different
Memory Store is one workspace, one shared view. Cruma's brain is per-Space + per-member — private by construction.
An editorial briefing for your day, not a dashboard.
Dashboards are widgets. You stare at them, decide what to attend to, and the morning's gone. The Brief is a different thing entirely: a written morning report from your workspace, paragraphs and numbered story cards, surfacing what the agent thinks you should know first.
It reads like a thoughtful chief-of-staff caught up with everything overnight and is now sitting across from you with two paragraphs and a few cards. Not a feed. Not a stream. A report.
What's in the Brief
- The lede — a paragraph or two from the agent about what mattered since you last logged in. Customer replies, deals that moved, things that broke or shipped.
- Story cards — numbered, ranked items the agent thinks deserve your attention this morning. Each is one tap deep — open the card to see the source, the agent's reasoning, and the suggested action.
- What the brain learned — distilled observations from the last 24 hours of email, meetings, and conversations. Each one is clickable back to its source: the Gmail thread, the Slack permalink, the calendar event.
- Your Spaces — quick-jump tiles into each working surface. The exact same cards your sidebar has, surfaced here because the morning isn't always about checking the inbox first.
If the cockpit is the operator's command center, the Brief is the moment before you take command. The orientation pass. The "here's what's true this morning" before you decide what to do about it.
What it is
The home view of your cockpit — a written editorial briefing assembled from everything the brain knows changed.
Where it lives
At app.cruma.ai/home. First thing you see when you log in.
What's different
It reads more like a Bloomberg report than a Notion dashboard. Designed to be read, not configured.
The work you'd repeat — repeated.
Most of the work a founder-led company runs through isn't novel. It's the same shape every time: lead comes in, qualify, draft, follow up. Customer asks about pricing, the answer is whatever you've already decided, the message just needs to land. The agent's job is to run those repeating shapes without you typing them every time.
Two ways that shows up in Cruma — both live inside a Space, both honor the brain's boundaries.
Workflows — repeatable automations
- Manual — a button you press when you want this exact sequence to run. The agent does the steps in order.
- Scheduled — cron-shaped runs. The morning brief is one of these. A Friday status email is another.
- Signal-fired — the workflow watches for something specific (a hiring spike, a stack change, an inbound email that matches a pattern) and runs when that signal fires.
- Every workflow is glass-box: you see what it's about to do before it does it, and you can stop it mid-flight.
Procedures — the SOPs the agent reads
- Written in plain English. "When a prospect replies asking about pricing, never quote a number — book a 15-minute slot."
- Lives inside the relevant Space. The agent reads the procedure before acting in that context.
- You change it once, in one place. Every future run picks up the new version. No "now go update the prompt in fourteen workflows."
- The procedure is the source of truth. The chat is just one way to invoke it.
The difference between an AI assistant and a real operator is that the operator has procedures. Cruma's agent has yours.
What they are
Workflows = repeatable runs. Procedures = the SOPs every run reads first.
Where they live
Inside each Space's sidebar. Author one, every future run honors it.
What's different
Most AI tools are session-shaped. Cruma's work is recurring-shaped by default.
The keyboard surface for every action.
The cockpit is the long-form surface — chats, briefs, spaces, dashboards. The Notch is the opposite: a small, always-available native macOS bar that lives at the top of your screen, summoned by a shortcut, dismissed by a keystroke. It's how you do quick things without leaving whatever app you're already in.
What you do from the Notch
- Ask — a quick question to the agent. Same brain as the cockpit; same boundaries.
- Capture — paste an article, drop a thought, dictate a note. Goes straight into the brain, attributed to you.
- Trigger — fire a workflow without opening the app. "Draft the follow-up to Rey." Done; pending your approval.
- Approve — the agent surfaces pending approvals here too. Three keystrokes to read the diff, approve or revise.
The Notch is what makes Cruma feel ambient. Most of the work doesn't require sitting in the cockpit. The cockpit is where the long-form happens — reviews, sessions, planning. The Notch is for the seventy-percent of daily interactions that are one question, one capture, one approval.
What it is
A native macOS bar at the top of your screen. Summon with a keystroke, dismiss with a keystroke.
Where it lives
Anywhere. It floats above whatever app you're in.
What's different
Most AI tools live in their own window. The Notch lives between the windows.
Your brain, inside the AI you already use.
Some work doesn't happen inside Cruma. It happens inside Claude Desktop, ChatGPT, Cursor, Raycast. The Model Context Protocol is the standard that lets any agent talk to any backend — and Cruma is built to be one of the most useful backends an agent can talk to. You paste a URL into your AI client of choice, and every conversation in that client suddenly has access to your workspace's brain.
Two URLs, two privilege tiers
Most "give your AI access to your data" tools give you one URL per workspace. Anyone with the URL sees everything the workspace can see. That's fine for a solo founder; it's a security incident waiting to happen the moment a workspace has more than one person.
Cruma gives you one URL per member. Each URL is signed to a specific person; the brain's visibility filter applies their role and identity when answering. The owner's URL sees leadership-tier rows and their own private memory. A member's URL sees workspace-tier rows only — leadership memory is invisible, other members' private memory is invisible.
- Workspace URL — least-privilege. Returns only workspace-tier memory. Right for shared service accounts or read-only integrations.
- Per-user URL — bound to one workspace member. Same view they'd see in the cockpit. Owner sees leadership; member doesn't.
- Tokens are not derivable from each other. Leaking one URL doesn't expose any other.
- Rotating the signing secret revokes every issued URL at once.
What you can do with it
recall— semantic search over your workspace's memory, scoped by Space and by the asker's tier. Each hit returns a source citation back to the original Gmail thread, Slack permalink, calendar event, or session summary.checkin— open a Claude session and instantly have it summarize what's been moving in your business since you last spoke to it. (Coming with the cockpit's auto-instruct integration.)record— write a fact to memory explicitly. The agent stamps it with the right Space and the right visibility tier.- Plus every workflow you've authored in Cruma — they show up as callable tools inside Claude / Cursor / whatever client you're in.
Memory Store's MCP is workspace-bound. Cruma's MCP is the first one that respects who's asking.
What it is
An MCP server that exposes your workspace's brain to any AI client that speaks the protocol.
Where it lives
Settings → Integrations in the cockpit. Each member generates their own URL.
What's different
Per-user URLs. Per-member visibility. The brain you trust in-app, traveling with you.
Five surfaces. One substrate. One workspace that knows what it's doing.