Your Mac can finally remember your work, act on it, and prove what it did. A verifiable AI execution system for macOS.
MemoryAgent watches what you're working on and remembers it for later. Ask it to find something, move a file, fill out a form, or pick up where you left off. It does the work and keeps a receipt. Everything stays on your Mac unless you say otherwise. Plans, executes, and verifies multi-step workflows across your apps, files, and web, or answers factual questions with source-verified evidence. Machine-checkable evidence at every step. No cloud processing. No uploads. Privacy-gated external research. No telemetry.
ContentView.swift in XcodeQ2 Budget.xlsx in Numbers
developer.apple.comgoogle.com/flights
Discussed architecture with teamPlanned weekend trip with friends
Three pillars that make MemoryAgent fundamentally different from AI assistants that just say "done." Most AI tools just talk. MemoryAgent acts on your behalf and keeps a receipt for everything it does.
Your intent is compiled into a GoalGraph: a directed acyclic graph that enables parallel operations, explicit dependencies, and partial failure recovery. Not a chain of prompts. A structured execution plan the system can validate before running. When you ask MemoryAgent to do something, it builds a step-by-step plan, checks that it's safe, then runs it. If something goes wrong partway through, it knows exactly where and can pick up from there.
Every action produces machine-checkable evidence. File operations are verified by hash. UI actions are verified by accessibility snapshots. Browser actions are verified by DOM state. When MemoryAgent says "done," you can prove it. Every time MemoryAgent does something, it takes a receipt: a screenshot, a file fingerprint, a before-and-after. So when it says "done," you can actually check.
Built on Apple's SystemLanguageModel with guided generation for structured, reliable outputs. All processing happens locally on your Mac. No cloud, no uploads, no telemetry. Available only on devices with Apple Intelligence enabled. MemoryAgent uses the AI built right into your Mac. Your data never leaves your computer. No accounts, no cloud services, no sign-ups. Just your Mac, working smarter.
From observation to verified execution. A pipeline built for trust.
MemoryAgent privately captures your active windows, apps, and content using macOS accessibility and vision APIs. Locally, encrypted, and governed by your privacy mode. MemoryAgent quietly watches what's on your screen: which apps are open, what files you're working on, what pages you're reading. Everything stays private on your Mac.
Foundation Models extract structured signals: which app, which file, what action, building semantic understanding of your work. It figures out what you're actually doing: which app, which document, what kind of work, and remembers it all.
When you make a request, MemoryAgent builds a GoalGraph: a validated execution plan with explicit steps, dependencies, and verification specs. When you ask it to do something, it breaks the job into steps, checks that each one is safe, and maps out the order.
Each step runs with pre/post state capture. Every action produces artifacts: screenshots, file hashes, command outputs, UI snapshots. It carries out each step and takes a snapshot before and after, so you always have proof of what changed.
MemoryAgent responds with typed conversation cards: approvals, drafts, status updates, resume prompts, and routed follow-ups. Review, edit, or approve before anything ships. Interrupt or resume at any point. When you need proof, it's there. Ask what you worked on, tell it to do something, or both at once. It sorts the request, shows the right kind of response, and keeps the proof attached so you can review before anything important goes out.
MemoryAgent understands intent from plain English. You don't type commands. You describe what you want, and the system infers whether to query, execute, explain, or combine multiple operations. A single request like "find my notes from yesterday's meeting and move them to the Project folder" decomposes into search, then action, handled safely. Just talk to it like a person. Say "find my notes from yesterday's meeting and move them to the Project folder" and it figures out the rest: search first, then move, done safely.
Execution modes like /plan, /query, and /learn are optional controls: explicit constraints for when you want to limit behavior, inspect the system, or teach it new skills.
If you want more control, there are special commands you can use. But most of the time, you just talk normally.
Teach MemoryAgent a workflow or skill. Describe what you want it to learn and it acquires it for future use. Teach it something new. Show it how you do a task and it remembers for next time.
Preview the GoalGraph without running it. See exactly what would happen before committing. See what it would do before it does it. A dry run you can review.
Force read-only mode. Side effects rejected at the gate, guaranteed safe. Just look, don't touch. It answers your question without changing anything.
Get evidence-anchored explanation of any past run. See exactly what happened and why. Ask it to explain what it did and why. It shows you the receipts.
AI-powered failure analysis with ranked hypotheses and evidence citations. Something went wrong? It figures out what happened and gives you its best guesses why.
Search your work history explicitly. Find that file, that page, that conversation. Search your memory. Find that file, that page, that conversation from last week.
Set condition-triggered automations. "When X happens, do Y." Set up automatic reactions. "When a new file appears in Downloads, move it to Documents."
Time-triggered execution. "Tomorrow at 9am, summarize my calendar." Schedule tasks for later. "Tomorrow morning, show me what I was working on."
A pipeline designed for trust, transparency, and reproducibility. The pieces that make MemoryAgent reliable, transparent, and trustworthy.
Requests are compiled into a directed acyclic graph with typed nodes, explicit edges, and verification specs. Validated before execution. Cycles rejected, dependencies checked, safety gates enforced. Your request gets broken into a step-by-step plan. Each step is checked for safety before anything runs.
Comprehensive verification: file existence, content hashes, UI element presence, DOM selectors, clipboard state, app running status. Evidence captured, not assertions accepted. It checks everything: did the file actually get created? Is it the right one? Is the app running? Every action gets a receipt so nothing slips through.
Every execution produces a complete bundle: the original GoalGraph, execution logs, verification reports, and captured artifacts. Inspect, replay, or debug any run. Everything MemoryAgent does gets saved in a neat folder: the plan, what happened, the proof, and any files it touched. You can look back anytime.
Execution can be interrupted and resumed from any checkpoint. Runs can be replayed deterministically from persisted bundles. Branch decisions and approval gates are honored. Interrupt a task and come back later. It picks up right where it stopped. You can also replay past tasks to see exactly what happened.
Whether you're coding, leading, or creating, MemoryAgent adapts to your workflow.
Never lose the why behind your code. Never lose track of what you were doing.
Never lose context when switching between files, debugging sessions, or documentation. MemoryAgent records what happened, why it happened, and what evidence proves it. Switching between tasks all day? MemoryAgent remembers what you were working on, what changed, and why, so you never have to retrace your steps.
Operating context without the recap tax.
Keep track of decisions, conversations, follow-ups, and the evolution of your company's thinking, with sources and open loops attached.
Your ambient companion that remembers across sessions. It remembers where you left off, even days later.
MemoryAgent runs as a bounded daily-use companion. The Companion Inbox surfaces active context, resumable work, project memory, and open loops. Interactive controls let you quiet, defer, accept, dismiss, or tune initiative on your terms. Come back to your Mac after a weekend and pick up exactly where you left off. MemoryAgent keeps your current context, loose ends, and next steps in one place, then stays quiet when you need to focus.
MemoryAgent exposes a local Model Context Protocol server so tools like Codex, Claude Code, and other MCP clients can inspect context, query operating state, and delegate bounded execution without taking ownership away from the runtime. Instead of rebuilding your desktop state from chat history, they can ask MemoryAgent for the local truth directly.
Read-only access to capabilities, live context, and recent perception via memoryagent:// resources. Your agent can gather the local truth without side effects, instead of spending tokens reconstructing state from pasted context.
Query active runs, resumable checkpoints, project memory, schedules, monitors, and communication queues in real time. That means external agents can stay efficient and state-aware without polling blindly or asking you to restate what is already known locally.
Trigger tasks, resume runs, and receive structured results through MCP tools. Clarification receipts, approval boundaries, verification artifacts, and resume flows keep the caller in control while MemoryAgent handles the local execution surface.
Unix-socket broker with client leases. Staged escalation from read-only context to full-parity runtime lets familiar agentic tools stay lightweight while MemoryAgent provides the stable local backend and verification layer.
MemoryAgent is built from the ground up with privacy as a core principle. All screen analysis, memory storage, and AI processing happen locally on your device. We never see your data, and neither does anyone else.
Choose your privacy level based on your needs:
Defense in depth: risky operations are blocked before they run, not after.
/query mode, side-effecting operations are rejected before execution.
Proof-backed today, with active work focused on unfamiliar-task understanding, bounded research, and safer action.
Core product surfaces that are already real in the current repo.
GoalGraph planning, approval gates, machine-checkable verification, and bounded multi-step execution are live. It can plan work, carry it out carefully, and prove what it did.
Run bundles, MCP run resources, and replayable artifact receipts make outcomes inspectable after the fact. Every run keeps a receipt you can inspect later instead of asking you to trust a black box.
The companion inbox, project memory, resumable work, initiative controls, and cross-day continuity are in daily-use shape. It can keep track of active work, remember what matters, and help you pick things back up later.
A bounded transactional browser lane now handles form fill, validation, table flows, upload/download flows, and async SPA navigation. It can handle a focused set of browser tasks safely instead of just talking about them.
A first-class semantic task model, stronger clarification, route-fit reasoning, and bounded task-success modeling are now wired through planning and persistence. It is getting better at understanding what kind of task you mean, what is missing, and what it can honestly do next.
Bounded research now preserves source roles, evidence hierarchy, freshness and conflict posture, and reusable synthesis artifacts. It can show which sources mattered and how strong a conclusion really is.
Explicit action eligibility, fail-closed missing-signal handling, checkpoint-aware pause/resume, and operational lineage are live. Before it acts, it is stricter about when it should stop, ask, or wait.
Local MCP backend with read-only context, operating-state surfaces, delegated execution, and shared runtime ownership.
The current frontier is less about adding features and more about widening understanding safely.
Improving semantic task understanding across unfamiliar requests, surfaces, and mixed-context workflows. Getting better at understanding unfamiliar tasks without pretending it understands everything.
Expanding bounded research from single-lane retrieval into stronger corroboration, conflict handling, and reusable evidence chains. Improving how it compares sources, handles uncertainty, and explains why an answer is trustworthy.
Extending fail-closed action policy, observation requirements, and checkpoint behavior across more novel surfaces. Making it safer and more reliable when work lands on screens or states it has seen less often.
Product expansion that still matters, but is not the main current bottleneck.
Securely carry MemoryAgent context across multiple Macs without weakening privacy or operator control.
"MemoryAgent exists so your Mac can remember what happened, help with what is next, and show its work."
We believe the next useful computer does more than answer questions. It should keep context, carry out real work carefully, and make its actions inspectable.
MemoryAgent is our version of that: a macOS-native execution layer built around operator control, replayable evidence, and trust.
See MemoryAgent in action. We'll show you how it can transform your workflow.
Or email us directly at hello@memoryagent.dev