@mention Recall. Hand it the work.
Recall is the Slack-native teammate you delegate to. @mention it on a task and it acts on your team's knowledge — answers the question, then files the doc, runs the runbook, and follows up. It still remembers everything your team figured out; now it does something with it.
Coming soon · Built on Schema0
Jordan
@Recall a customer's asking for a pro-rata refund on their annual plan — can you handle it and reply to the ticket?
Recallboton it
Done. Refunded pro-rata per our 30-day policy, replied to the ticket, and logged it in #billing. Flagged one edge case for you to confirm.
Coming soon
What ships when Recall lands
Recall isn't generally available yet. Here's what will be in the box the day it opens — every capability framed for launch, nothing live today. Join the waitlist to be first in.
@mention to delegate
Tag @Recall on any task in a channel and hand it off — it acts on your team's knowledge, not just answers about it.
Async, autonomous runs
Recall will schedule its own steps and carry a project over hours or days, keeping the thread updated as it goes.
Admin controls & scoped access
Per-channel permissions, separate Recall identities, spend limits, and activity logs — the trust layer ships with the product.
Ambient updates
Opt into proactive nudges so Recall surfaces what needs your attention before you ask — rolling out to waitlist teams first.
How it works
Hand off a task, right where you already talk
Three steps, no migration project. You delegate in a thread; Recall does the work and keeps the channel in the loop.
@mention to delegate
Tag @Recall in a channel and describe the task in plain language. No new tool, no separate login — you hand off work right where your team already talks.
Recall acts on it
It pulls from your team's knowledge and its granted tools to do the work — answers the question, files the doc, runs the runbook — scheduling its own steps if the task runs long.
Everyone stays in the loop
Recall keeps the thread updated and cites what it acted on, so the whole channel can see progress, verify the work, and jump in without a handoff.
Why Recall
A teammate that remembers — and acts
One teammate, shared by the channel
Every channel gets a single @Recall the whole team works with. Teammates see the task it's running, jump into the thread, and pick up where anyone left off — not a private DM bot per person.
Learns your team as it works
Recall builds durable knowledge from channel activity — decisions, runbooks, the way you do things. Grant it more channels or sources and it carries that context into every task it takes on.
Proactive, not just on-demand
Turn on ambient mode and Recall keeps you posted on what it thinks you need — a stalled thread, a doc gone stale, a follow-up owed — before you go looking for it.
Delegate and walk away
Hand off a task and close the tab. Recall works asynchronously over hours or days, schedules its own next steps, and pursues a project to done without being re-prompted.
Remembers and shows its work
Recall still answers from your team's real knowledge and cites the message or doc behind every reply — so when it acts, you can see exactly what it acted on.
Scoped and secure by design
Recall only ever touches the channels, tools, and data an admin grants it, and always respects Slack membership. Scoped access is the default, not an afterthought.
Where teams delegate
One teammate, every team's work
Resolve the ticket, not just cite the policy
@Recall the refund, the exception, the how-do-I — it applies the policy, replies to the ticket, and logs it, so your team clears the queue instead of re-answering it.
Runbooks that run themselves
@Recall to rotate the staging DB or walk a deploy — it follows the runbook you already wrote, reports each step in-thread, and flags anything that needs a human.
New hires delegate, not interrupt
Hand @Recall the setup, the access request, the where-does-this-live — it does the legwork and follows up, without pulling a senior engineer out of flow.
Delegate the follow-through
@Recall to chase the vendor, file the decision, or check on a stalled thread — it pursues the task over days and keeps the channel posted until it's done.
Admin control & trust
Powerful, and on a leash
Recall is an agent that acts — so control comes first. Admins decide exactly what it can reach, who it acts as, how much it can spend, and can audit everything it's done, before anyone delegates a thing.
Scoped access
Grant Recall only the specific channels, tools, data, and codebases it needs. Access is explicit and respects Slack membership — nothing leaks across teams.
Separate identities
Spin up distinct Recall identities for different uses — support, engineering, ops — each scoped to its own channels and permissions, so one agent's access never bleeds into another's.
Spend & token limits
Set per-identity token and spend caps so an autonomous run can work for hours without ever running past the budget you set.
Full activity logs
Every task Recall takes on and every action it runs is logged and auditable — so admins see exactly what it did, where, and why. Autonomy never means opacity.
Built on Schema0
The proof that agents ship on Schema0
Recall runs on the same Postgres, auth, storage, and functions we give every builder on Schema0 — no bespoke infra team, no one-off stack. An agent that remembers your team, acts on its own, and holds up under real permissions is exactly the kind of product Schema0 is built to make feel reliable out of the box. Recall is our proof, and a preview of what you can ship too.
FAQ
Questions, answered
How is this different from the old Recall knowledge bot?
Recall used to just answer questions with citations. The new Recall still does that — but now you @mention it to delegate real work. It answers, then acts: files the doc, runs the runbook, follows up, and schedules its own next steps. It moved from a thing you ask to a teammate you hand work to.
When can I use Recall?
Recall isn't generally available yet — it's coming soon. Join the waitlist and we'll bring your team on as capabilities land at launch. If you want to talk through your setup before then, talk to the team.
Is one Recall shared, or does everyone get their own?
Each channel has one shared Recall that the whole team works with. Everyone sees its ongoing work and can resume any thread it started — that's what makes it a teammate rather than a personal assistant.
Can admins control what Recall can touch?
Yes — that's core to the design, and it ships at launch. Admins scope Recall to specific channels, tools, and data, spin up separate identities for different uses, set token and spend limits, and review full activity logs. Recall always respects Slack channel membership, so nothing leaks across teams.
What is Recall built on?
Recall runs on the Schema0 backend — the same Postgres, auth, storage, and functions we give every builder. It's our own proof that agent-shaped products can feel reliable out of the box.
Stop asking your team. Start delegating to it.
Recall is coming soon as your agentic Slack teammate. Join the waitlist and we'll email you the moment early access opens.
Prefer to talk it through? Talk to the team