Local-first AI workspace · Extension, web, and desktop

Stop re-explaining your work to your AI.

Memorall remembers the pages, files, and decisions you already worked through, then hands that memory to an agent that can read the page you are on, open your documents, and run real code. It runs on your machine, with free on-device models or your own API key.

Add To Chrome - Free Try It In The Browser Desktop Apps

No account required Works offline with on-device models Your data stays on your device MIT open source

Topics

Daily work active

API prototype 8 docs

Research brief 9 nodes

Documents

browser-agent-notes.md md

product-research.pdf pdf

provider-matrix.xlsx xls

remembers 14 sources local model · offline

Pick up the pricing research from last week and turn it into a one-page brief.

Found it. The three tabs you saved, the competitor PDF, and your notes from the Tuesday thread are all still linked to that topic.

Draft is in your workspace. I can open the two sources that changed since then, or run the numbers in the sandbox before you send it.

You never repeat yourself Pages, files, and threads from last week are still attached to the work instead of lost in an old chat.

It can finish the job The same agent browses live pages, edits your files, and runs code without leaving the workspace.

Knowledge graph

Enabled tools

Browser session dom

Workspace FS rw

Node sandbox npm

Flow builder graph

It remembers what you were working on

Ask about the page you are reading

No account, no subscription to start

Free on-device models

Bring your own API key

Works offline

Reads your PDFs, notes, and sheets

Runs real code in a sandbox

Answers you can click, not walls of text

Extension, web, Windows, macOS, Linux

It remembers what you were working on

Ask about the page you are reading

No account, no subscription to start

Free on-device models

Bring your own API key

Works offline

Reads your PDFs, notes, and sheets

Runs real code in a sandbox

Answers you can click, not walls of text

Extension, web, Windows, macOS, Linux

Why Memorall

Your work has a history. Your assistant does not.

You spend the day in tabs, docs, PDFs, and dashboards. Then you open a chat window and start from nothing - pasting context, re-explaining the project, describing files it cannot see. Memorall is built for that gap. It keeps the working context, and it keeps it on your machine.

Today

Every session starts from zero.

The assistant is fast, but it is a stranger every morning. The context lives in your tabs and in your head, and moving it into the chat is the actual work.

FORGETS

You re-explain the same project every time Yesterday's thread is gone, so today you paste the same background, links, and constraints again.

BLIND

It cannot see what you are looking at The page, the PDF, the spreadsheet, and the notes are right there, and the chat window has no idea they exist.

EXPOSED

Everything you paste leaves your machine Research, client material, and half-finished thinking all ship to someone else's server just to get an answer.

STUCK

It stops at the answer It can describe the next step, but it cannot open the page, edit the file, or run the code to actually take it.

With Memorall

One assistant that already knows the project.

Save a page, a selection, a PDF, or a note once. It becomes durable memory attached to a topic, and every future question starts from there instead of from an empty box.

REMEMBERS

Pick up where you left off Topics keep pages, documents, conversations, and the links between them, so week-old work is one question away.

PRESENT

It works on the page you are on Right-click any page and a panel opens beside it. Ask about the article, a selection, or a screenshot without switching tabs.

PRIVATE

Local by default, not as a setting Memory, documents, and even the model can run entirely on your device. No account is required to use the core app.

CAPABLE

It finishes the step, not just the sentence The same agent browses live pages, edits workspace files, and runs Node code in a sandbox to check its own work.

Memory

Save it once. Ask about it forever.

The first job is memory. What you save is not dropped into a prompt and forgotten - it is converted into topic-scoped knowledge with the source still attached, so you can search it, inspect it, correct it, and ask about it months later.

Save without breaking your flow

Right-click a page, highlight a paragraph, drop in a PDF or a spreadsheet, capture a screenshot. It goes into a topic in one action - no export, no copy-paste, no second app.

Pages + selections PDF, Markdown, Excel Screenshots

It becomes knowledge, not a bookmark

Saved material is converted into a topic-scoped knowledge graph: the facts, the relationships between them, and the source each one came from. You can open the graph and see exactly what it learned.

Knowledge graph Sources kept You can edit it

Recall that answers with receipts

Ask a question and retrieval combines exact matching with semantic search across the topic, so you get the specific fact and the context around it - with citations back to where it came from.

Hybrid retrieval Citations Long-running projects

Memory Flow

Watch a pile of tabs turn into something you can query.

Scroll through the four stages: what you captured, what it became, how it connected, and what comes back when you ask about it three weeks later.

Capture Convert Connect Recall

feature: Browser memory stage 1 of 4

The real working set

Webpages, PDFs, notes, spreadsheets, and snippets - the scattered material you actually used this week, saved from the browser session you were already in.

Turned into memory you can query

Each source is converted into graph-ready knowledge. This is the moment a bookmark stops being a link you will never open again and becomes context an agent can reason over.

The connections you never wrote down

Relationships form between ideas, files, pages, and earlier work. The links you were holding in your head become something you can open, search, and correct.

Still there next month

Come back after three weeks and the topic still holds the sources, the facts, and the reasoning. You ask a question instead of rebuilding the context.

On The Page

No copying into a separate app. It comes to you.

Most of the friction with an assistant is transport - getting what you are looking at into the box where the answer happens. The extension removes that step. Both surfaces below run directly on the page you are already reading.

Ask this page

What does this say about pricing?

Reading the section you highlighted

page selection shot

Ask this page

Right-click, and the answer arrives beside what you are reading.

A panel opens next to the article. Attach the whole page, just your selection, the underlying HTML, or a screenshot, then ask. You stay in the document, the answer lands next to the paragraph that prompted it, and you can save the whole thing into a topic on the spot.

Selection or full page Screenshots Save to a topic

Co-agent

Scrolled to section 3

Found the comparison table

Opening the linked source

Co-agent

Or let it drive, and watch every step it takes.

The co-agent joins you on the page instead of describing it from a distance. It reads the DOM, scrolls, points at what it found, and clicks safe targets - narrating each move from a dock in the corner, so you can follow the reasoning and stop it whenever you want.

Reads the live DOM Points and scrolls Narrates each step

What It Can Do

An assistant that can act, not just answer.

Memory tells the agent what your project is. These are the things it can reach for once it knows - all from the same workspace, all switchable per agent, none of them requiring a second product.

Browse

It can open the web and read it properly

Instead of guessing from stale training data, the agent opens pages, keeps a live browser session, inspects the DOM, waits for content to load, and acts on what is actually there.

Live pages DOM actions

Files

It can work with your documents

Upload, create, rename, and edit files across a document library and a writable workspace. Preview PDFs, images, and spreadsheets, edit Markdown, and tag anything into a topic so it becomes memory.

PDF, Markdown, Excel Readable and writable

Run

It can run code and check its own work

A sandbox runs Node.js right in the app: install packages, work with files, start a server, render the output. The agent can prototype, test, and show you a working result instead of a snippet you have to trust.

Node sandbox npm + local servers

Show

It answers with things you can click

Turn on Visualize Response and replies come back as interactive components - stat cards, charts, tables, and actions - instead of a wall of text you have to read twice to pull the number out of.

Charts and tables Clickable actions

Build

Every capability is a switch, not a fork

Memory, web, sandbox, filesystem, planning, visual answers - each one is a toggle on the agent. Start from a template or describe what you want in the wizard, then keep refining it as the job changes.

Agent wizard Toggle per agent

Own

Go deeper when the defaults stop fitting

Under the surface every agent is a graph you fully own: your own nodes, your own flow logic, your own tools and conditions. Add new graphs and steps without touching the existing ones - the shipped agents are examples, not the ceiling.

Visual flow builder Custom tools + graphs

First Run

From install to a working agent in a few minutes.

No waitlist, no credit card, no mandatory account. Pick how you want to run it, and the rest of the setup is a handful of screens.

Start your way

Choose free on-device models, your own provider key, or the managed option. All three lead to a usable app - the choice is about cost and privacy, not features.

Bring your own key, safely

If you use OpenAI or OpenRouter, the credentials are encrypted with AES-256 behind a single master passkey rather than sitting in plain storage.

Pick a model

On-device WebGPU and WASM runtimes sit in the same catalog as remote models, so local-first and remote are one dropdown rather than two different products.

Build an agent

Start blank and describe what you need in chat, or take a template and refine it in the wizard. Either way you end up with an agent shaped around your job.

Switch on what it needs

Memory, tools, web access, sandbox, visual answers - flip on the capabilities this agent should have and leave the rest off.

Ask it something real

The answer comes back as components you can read and click, with its sources attached and the work saved into the topic for next time.

Local-First

Nothing has to leave your device.

Local-first here is architectural, not a badge in the footer. The product is fully functional with no external service: the database, the files, the background jobs, and the model can all run on your machine. Cloud is something you opt into, not out of.

Your data

The database lives in the app

Pages, topics, graph, conversations, and files are stored locally in PGlite. There is no server database to trust and nothing to sync unless you decide to.

Your models

Real on-device inference

Wllama, WebLLM, and Transformers are first-class runtimes, not degraded fallbacks. With WebGPU they are quick enough for daily work, and they cost nothing per message.

Your account

No sign-in required

Authentication is optional and off by default. You can install it, use it for months, and never create an account.

Your exit

Portable, and open source

Memorall is MIT licensed, so you can read exactly what it does. A portable export format is the migration path between installs - there is no cloud lock-in to escape from.

Models

Change the model without changing how you work.

Run a free model on your own hardware for everyday questions, then send the hard one to a frontier model with your own key. Your memory, files, tools, and agents stay exactly the same - only the engine behind them changes.

One workflow, many engines

You pick the trade-off per job, not once and forever.

Prompts, memory, files, tools, and routing all pass through Memorall first. From there the same workspace can call an on-device model, a local server like Ollama or LM Studio, or a remote provider - and nothing about your setup has to move.

Memorall Your memory, files, and tools in front of every model

OpenAI your own API key
OpenRouter many models behind one key
OpenAI-compatible your own gateway or proxy
Ollama models already on your machine
LM Studio local server runtime
WebLLM on-device, WebGPU accelerated
Wllama on-device, runs without a GPU
Transformers.js on-device chat and embeddings

Free by default

On-device models are the starting point.

You can use Memorall for real work without ever entering a key. WebLLM, Wllama, and Transformers run inside the app itself - no per-message cost, no network round trip, and they keep working when the connection does not.

Your choices

Every option, one control surface.

On-device WebLLM, Wllama, and Transformers.js - free and offline

Local servers Ollama and LM Studio, if you already run models locally

Remote providers OpenAI, OpenRouter, and OpenAI-compatible endpoints with your key

Embeddings 384d, 768d, or 1536d, switchable with live reload

What never changes

Switching the model does not reset your work.

Topics, documents, the knowledge graph, browser tools, and your custom agents all sit above the model layer. Move from a local model to a frontier one mid-project and everything you built is still there.

Topic memory Browser tools Workspace files Custom agents

Privacy

You do not have to take our word for it.

Memorall is MIT licensed and the whole codebase is public. The privacy claims on this page are things you can verify by reading the source, which is the only kind of privacy promise worth much.

Read Privacy Policy Read The Source

No account

Sign-in is optional

The core app runs without an account or a hosted database. Auth exists for people who want it, and stays off until then.

Local storage

Your data stays where you put it

Pages, graph data, files, and conversations live in local storage backed by PGlite - on your device, not on a server.

Encrypted keys

Provider credentials are protected

API keys are encrypted with AES-256 and unlocked through a master passkey instead of sitting in plain text.

No silent sync

Nothing ships in the background

There is no cross-device cloud sync by design. If content reaches a remote provider, it is because you chose that model.

Get Memorall

Install it wherever you actually work.

One product, five ways to run it. The browser extension is the most complete experience and the only surface that can work on the page you are reading. The web app needs no install at all, and the desktop apps give the agent a native host on your machine.

Browser extension

Chrome · Edge · Chromium

The full experience: the in-page assistant, the co-agent, right-click capture, and browser automation. This is where Memorall is most useful.

Available now · free

Add To Chrome

Edge and other Chromium browsers install the same package, or load an unpacked build from source.

Web app

Any modern browser

The same workspace, memory, documents, and agents with nothing to install. The fastest way to find out whether Memorall fits how you work.

Live · no install

Open The Web App

In-page capture and browser automation need the extension; everything else works here.

Windows

Windows 10 and 11

A native desktop app built on Tauri 2. Executable, MSI, and NSIS installer builds are verified, and the release app opens without a terminal window behind it.

Verified build

Get The Windows App

Or build it yourself with yarn build:desktop:windows

macOS

Apple silicon and Intel

The same Tauri 2 desktop app for Mac. Build support ships in the repository; the package is compiled, signed, and notarized on macOS itself.

Build on macOS

Check Releases

Build on a Mac with yarn build:desktop:macos

Linux

WebKitGTK hosts

A native Linux build of the same desktop app, compiled on a Linux host with the WebKit and GTK dependencies in place.

Build on Linux

Check Releases

Build on Linux with yarn build:desktop:linux

What you get on each surface

The workspace itself is the same everywhere. These are the differences that actually change what you can do.

Scroll the table sideways to compare all three.

Memorall capabilities compared across the browser extension, desktop apps, and web app
Capability	Extension	Desktop	Web
Workspace, memory, documents, knowledge graph, agents	Yes	Yes	Yes
On-device models and embeddings	Yes	Yes	Single-thread baseline
In-page assistant, co-agent, and selection capture	Yes	No	No
Browser activity tracking	Yes	No	No
Agent browser automation	Your tabs	Bundled Chromium	No
Chat through a remote provider	Yes	Yes	Provider CORS
Native folders, local commands, npm, and MCP stdio	No	Rolling out	No
Notifications	Yes	Yes	Needs permission
Automatic cross-device sync	By design	By design	By design

Data stays local to each installation, so there is no cloud sync to switch off. Moving between surfaces is a portable export and import instead.

Not sure which one? Start with the extension if you spend the day in tabs - it is the only surface with the in-page assistant and the co-agent. Add the desktop app when you want the agent to have a native host on your machine. Open the web app if you just want to see it working in the next minute.

Same workspace on every surface Data stays local to each install Portable export between them

Get Started

Give your assistant a memory, and keep it on your machine.

Free, open source, and usable without an account or an API key. Install it, save the first page, and see what it is like when the assistant already knows the project.

Add To Chrome Try It In The Browser View On GitHub