BECKI
Becki is shared memory across your AI tools. Astir is an agent workspace built to put that context to work. On scroll, Becki's faceted core rotates and settles into Astir's chest. This is a visual illustration, not a live product operation.
Your work.
Without the reset.
Becki remembers across your AI tools.
Astir puts that context to work.
Becki.
Decisions and reasons.
Kept beyond a session.
One memory.
Every AI you use.
What you teach one, the others remember.
The dead ends too.
A new session should not lose the reasoning from the last one or suggest a path you ruled out last week. Keep your preferred editor and connect Becki, or work in Astir. Either way, Becki keeps the context for the next session.
Becki is the memory.
Becki keeps decisions and their reasons, commitments, and approaches that did not work. Your authorized AI tools can ask for that context instead of relying on the history inside one chat.
What Becki keeps
Astir is the workspace.
Work with an agent, your chosen model, and the tools you connect. Astir uses the shared history Becki supplies. They are separate products that work together.
Where Astir fitsYou should not have
to be the memory.
Your context is scattered across tools that do not share it. The useful part of yesterday's work becomes another thing you have to explain today.
New tool. Missing context.
Your project has a history. A new tool may not have it. Switching tools can mean rebuilding the context before you can make progress.
Preferences do not follow you.
Each new tool needs to learn how you work, which constraints matter to you, and the language you use.
The reasoning gets buried.
The answer is in a transcript somewhere. When the question comes back, it is harder to find why you chose it or which alternatives you rejected.
You are the glue.
Copying context between chats is work. Remembering which version is current is more work. Becki gives your tools a shared place to ask, instead of making you relay everything.
Keep the thinking.
Not just the answer.
A transcript tells you what was said. Useful memory tells you what was decided, why it mattered, and what still needs attention.
- Decisions
- The choice and its reasoning: the problem, the alternatives, the constraints, and why this approach won.
- Dead ends
- The paths you tried or ruled out, with enough context to understand why. A future session can check them before proposing the same thing again.
- Commitments
- What you owe, what someone owes you, and which project it belongs to. Keep the obligation where you can find it, not buried in a meeting transcript.
- Open loops
- Unanswered questions and unfinished work you need to return to. Close them when they are resolved so they stop appearing as work still to do.
Project context, preferences, and references help explain these entries. Keep a history you can use, not every line of text.
Give that memory
somewhere to work.
Astir brings your conversations, connected tools and agents into one workspace. Capture what you need, work across projects, and keep meetings and their next steps in view.
Work with an agent.
Ask a question, investigate a project, edit a file, or build an artifact. Astir can use the tools you enable to do the work, rather than just giving you instructions.
The desktop keeps chat, files, a terminal, previews, and Git review together. It shares sessions and skills with Astir's other interfaces, rather than keeping a separate history.
Becki can also serve your existing MCP-compatible tools. You do not have to move all your work into Astir to use the memory layer.
Choose the model for the job.
Use a configured provider and model rather than committing your workspace to one vendor. Provider access and credentials remain part of your setup.
See what the agent is doing.
Follow streaming tool activity, inspect files and diffs, and open the resulting page or artifact beside the conversation. Tool execution follows your configured permission and approval settings.
Keep sessions with their projects.
Associate sessions with projects and folders. Save procedures as reusable skills, and connect MCP servers for the services you need.
Workspace
Keep several conversations open beside files, terminal output, previews and Git review. Reopen Astir with the panes and layout you left visible, without reopening every retained conversation.
Connections
Choose your model providers and connect the tools and MCP services you use. Accounts, credentials and permissions stay part of your setup.
Relay
Send a task or question to another project desk without merging its conversation into yours. A queued handoff stays distinct from work that has started.
Capture
Select an area of your screen, choose an existing conversation, add a note and Send. If that conversation is busy, the capture waits for its next turn instead of interrupting the work.
Meetings and Calendar
Keep meeting recordings and transcription workflows alongside Calendar and Agenda. Open an event's details, read its notes and choose Join without leaving the workspace.
A new session.
The same reasoning.
You do not need to change apps to benefit from memory. Return to the same project in Astir, with the reasoning from the last session available through Becki.
ILLUSTRATIVE WORKFLOW · FICTIONAL PROJECT · NOT A LIVE VAULT QUERY
- 01 / DECIDE IN ASTIR
Choose queued exports.
While building a reporting feature in Astir, you decide that large exports should run as background jobs. Your agent saves the decision to Becki, including why: synchronous exports block the interaction and make retries harder.
- 02 / RETURN TO THE PROJECT
Pick up next session.
Later, you open a new Astir session to add another report. Before proposing a change, your agent asks Becki for the project history and can retrieve the queued-export decision, its rationale, and the rejected inline approach.
- 03 / CONTINUE IN ASTIR
Build on the decision.
You stay in the same workspace. The agent can use your enabled file and terminal tools to extend the feature with that context in view. If the constraints change, revisit the decision and save the new reasoning.
Prefer Cursor? Keep your editor and connect Becki's memory layer there. The same capture-and-recall pattern can happen across Cursor sessions. Astir is an alternative workspace, not a required stop in the workflow.
Read the retained decision in this example
- Project
- Report delivery · illustrative
- Decision
- Run large exports as queued background jobs.
- Reason
- Keep the application responsive and make failed exports retryable.
- Rejected path
- Generate every large report synchronously inside the request.
- Revisit when
- Report sizes or delivery constraints change. The decision is context, not an instruction that can never be replaced.
Record once.
Remember everywhere.
Becki works through MCP, the protocol AI tools use to reach external tools and context. Connected clients can contribute to and query the same memory.
- 01
Connect the tools
you already use.Authorize Becki in your AI clients and add the memory workflow to their instructions or skills. Local and web clients have different connection steps, but reach the same vault.
- 02
Capture what
is worth keeping.Your agent can save the decision and its why after meaningful work. Configured session and project ingestion can bring in existing context. Meeting capture, where available and enabled, adds another source; it is not required to use cross-tool memory.
- 03
Recall before
starting again.Ask for relevant project history before a new task. Decisions, rejected approaches, and open work arrive as context for the current question, not a pasted copy of every old conversation.
- 04
Keep the history
current.Close fulfilled commitments and mark decisions that have been replaced. Keep the history of what changed without leaving completed work on the to-do list.
Keep your tools.
Connect the memory.
Work in Astir with the model you prefer, or add Becki to an existing MCP-compatible client. Choose the workspace that fits your work, without giving up the reasoning worth keeping.
Grok
GROK MODELS / IN ASTIRUse Grok through a configured xAI provider in Astir, with Becki connected for project memory.
OpenAI
CODEX / CHATGPTUse OpenAI models in Astir, or connect Becki to Codex and ChatGPT through their supported setup.
Claude
CLAUDE CODE / DESKTOP / WEBUse Claude in Astir, or keep your Claude client and connect Becki's shared memory there.
Use model providers inside Astir, or connect Becki directly to supported MCP clients. Grok uses the Astir route; Codex, ChatGPT, and Claude clients have their own connection steps. Access depends on your account and setup.
Becki in your editor or desktop
- Codex
Claude Code- Claude Desktop
Cursor
Antigravity CLI
Zed
VS Code
Raycast
PerplexityMCP support, connector access, and setup vary by client. Your AI tools may also connect to GitHub, Gmail, Slack, Linear, or Notion through their own MCP servers. Becki keeps the map of that work: what was decided, where the spec lives, and who owns the next step. Service integrations belong to the client and the MCP servers you connect; Becki is the shared memory layer.
Your memory.
A clear boundary.
Becki combines on-device capture with a private, per-user cloud retrieval service. Know what stays on the device, what syncs, and how your authorized tools use that context.
Choose how audio is processed.
Local transcription processes audio on your device. If you configure cloud transcription, audio goes to that provider under its terms and your account settings. Recording a meeting is optional, not a prerequisite for connecting Becki to your AI tools.
Local recordings, selected AI processing and shared memory have different boundaries. A file saved on your Mac can still be sent to a provider for a task you configure.
The useful context can travel.
Relevant vault text and a retrieval index sync to Becki's private, per-user cloud service so authorized clients can recall context across tools. Synced data is encrypted in transit and at rest.
This is a hybrid architecture, not a zero-knowledge or end-to-end encrypted claim. When a connected AI tool receives context, its provider's data policies also matter.
The practical questions.
Do I need Astir to use Becki?
No. Becki connects to supported AI tools through MCP. Astir is an agent workspace that can use that shared memory, not a requirement for every other client. Keep the tools you use today, add Astir where it fits, or use them together.
My AI already has memory. What changes?
A tool's own memory generally stays with that tool. Becki supplies shared context that connected, authorized clients can query. The difference is continuity across tools, including the reasoning and rejected approaches, rather than starting another isolated history.
Does Becki automatically remember everything?
No. What is captured depends on your configuration, connected tools, enabled ingestion, and what your agents save. The memory workflow is to recall before substantial work and capture the durable context afterward. It is not a promise of perfect recall or universal recording.
Can I replace a decision or close a task?
Yes. A fulfilled commitment can be resolved, and a newer decision can supersede an older one. Keeping that relationship lets you retain the history without presenting outdated work as current. Your agent or the memory-review tools can help manage it.
Does everything stay on my device?
No. Local transcription processes audio on your device; configured cloud transcription sends it to the selected provider. Vault context and a retrieval index sync for cross-tool access, and selected text can be processed by Becki-managed services or providers you configure. Becki is not zero-knowledge. Read Trust and your provider's terms before sharing sensitive work.
How do I get started with my existing tools?
Create a Becki account, follow the published connection guide for your client, and give your agent the memory instructions or skills. Then ask it about a project with context you have captured. Browser clients may have plan or developer-mode requirements; check the guide for your specific tool.
Stop teaching every AI
from scratch.
Start with Becki in the tools you already use. Use Astir when you want an agent workspace with that memory available. Keep the reasoning when you change models or tools.