Memory that keeps itself up to date.
You write the rules.
Write the upkeep down once, as a note. Agents file, link, summarize, and check your knowledge on schedule, and every change can be kept or undone.
--- type: agent title: Agent briefing enabled: true schedule: "@daily" --- # Agent briefing Keep [[briefing]] current for the agents that work in this project: - What the project is and where it stands. - Open decisions, and who owns them. - Conventions: folders, note types, naming. - What changed since yesterday. Link every point to its source note. Rewrite the briefing; don't append to it.
An agent is just a note. This one briefs your coding agents every morning.
Your memory, programmable.
In plain language.
Every knowledge base decays. Notes pile up unfiled, decisions get buried in long conversations, and the summary your agents start from goes stale. Keeping it in shape is the chore nobody has time for.
In Basic Memory, the instructions for that upkeep are notes too. You decide how new notes get filed, what gets summarized, and what your agents read first, and the rules live right beside the knowledge they maintain. Your AI can read them, write them, and run them, the same way it works with any other note.
Basic Memory agents work in the open: instructions anyone can read or write, a trigger you choose, and a record of exactly what changed.
From instructions to reviewed work.
- 01
Instructions
An agent is a Markdown note with plain-language instructions. Write it in the web app or ask your AI to draft it, and edit it like any other note.
- 02
Trigger
Run it on a schedule, when a new note lands in a folder you choose, or on demand from the app or a connected AI.
- 03
Work
The agent runs hosted, so you don't keep a session open. It reads and changes only its own project, rereading any note someone else changed before it writes.
- 04
Evidence
Follow the run live, then see exactly which notes it created, edited, moved, or deleted, with its summary and the steps it took.
- 05
Review
Changes land during the run. A shared review queue collects the work afterward, so anyone on the team can keep it or flag a failure.
- 06
Improve
Inspect a diff, revert an edit, or restore a deleted note. Adjust the instructions right beside the result and run it again.
Start with one.
Make it yours.
Ten agents for the upkeep every knowledge base needs. Each is a starting point you can read and rewrite. Ones that watch folders or run on a schedule start switched off, so you review the instructions before anything runs.
Inbox filer
new note in inbox/Files quick captures into the right folder, sets their note type, and links them to related notes.
Import digester
on demandTurns imported Claude and ChatGPT conversations into topic and decision notes, 20 at a time. Run it on the index note each import writes.
Meeting follow-up
new note in meetings/Turns a meeting note into linked tasks and a short summary.
Decision extractor
on demandPulls each decision out of a long conversation or document, with the reasoning and the options you passed on.
Agent briefing
dailyKeeps one briefing note current, so Claude Code, Codex, and your own agents start from where the project stands.
Weekly reflection
weeklyWrites a digest of the week and folds lasting insights into the notes they belong to.
Curator
on demandLinks related notes and orphans, so the graph keeps its connections.
Contradiction check
weeklyReports facts that disagree, stale statuses, and broken links. Changes nothing else.
Schema keeper
on demandReports where notes have drifted from their note type's schema. Changes nothing else.
Cleanup
on demandMerges duplicates, archives finished work, and splits notes that grew too big. It changes notes directly and never deletes one.
Describe the chore.
An agent can do it.
Tell your AI what you want kept up to date. It writes the agent note, you read it, and it runs. For example:
Paste this into Claude, ChatGPT, or Codex connected to Basic Memory.
Use the memory-agents skill to design a Basic Memory agent with me. Look at how my project's notes are organized, then ask me which chore I want handled. Write the agent note, show it to me before saving, and run it on one note so we can review what it changed.
Your AI uses the memory-agents skill to write and run the agent note. Read the skill →
“Find tasks with no activity in 30 days, mark them stale, and list them by owner in a report.”
“Read the page, write a summary with its key claims, and link it to the notes it supports or contradicts.”
“Update each customer note's status from this week's call notes, and flag any customer we haven't talked to in a month.”
“Turn this spec into a checklist of open questions, one task note per question, linked to the spec.”
Agents work inside one project, with your notes as their tools. Reading the web is opt-in for each workspace and each agent. They don't send email or reach into other apps: they're agents for your memory, not a general automation platform.
Agents built to keep you
and your information safe.
Scoped to one project
An agent reads and changes only its own project. Whoever wrote its instructions and whoever starts it both need edit access there.
Revision-safe writes
Agents can only overwrite the version they read. If someone else changed a note mid-run, the agent rereads it first. Locked notes are off limits.
Bounded runs
Runs have time limits and a plan-based limit on how many run at once. Schedules run hourly at most, never overlap, and skip when nothing changed. An agent's own writes never trigger other agents.
Web access is opt-in
An agent searches and reads the web only when the workspace allows it and its own note asks for it, optionally limited to sites you list. It reads text pages only, up to 20 searches and reads per run (50 on Business); it doesn't download files, fill in forms, or sign in, and every search and page is in the run record.
Recovery with limits
Undo puts notes back and deletes the notes the run created, but never overwrites an edit made after the run: a note someone changed since stays, with its version history to choose from.
Runs use your plan's credits.
No per-agent fees.
Most runs use under 10 credits for the model and compute they take, and a big job, like a weekly reflection over a busy project, about 20. Every plan includes credits each month, shared with the rest of your workspace's work. Usage shows up by agent, so you can see what each one costs.
Past your included credits, each extra credit is $0.01, the same as included ones, added to your next invoice. A spending limit is on from day one: $38 a month on Cloud, $297 on Pro, and $498 on Business, and owners and admins can raise or lower it. When your workspace reaches it, agents stop: no new runs start, by hand or on a schedule, until you raise the limit or the next billing period begins.
Agents run on DeepSeek, an open model. Using open models is what keeps a typical run under 10 cents.
Run counts assume 10 credits a run and a plan's credits going only to agents. Agents are included on Cloud, Pro, and Business and in the free trial, not on older seat-based plans.
Your other agents need a memory too.
The agents you already run start every session from zero. Point them at Basic Memory and they pick up the same decisions, history, and context your team uses, and write back what they learn.
Every MCP client
Claude, ChatGPT, Codex, Cursor, Gemini CLI, and any MCP client read and write the same memory. Sign in once with OAuth.
Keys for headless agents
Scripts and autonomous agents connect with API keys. Make a key read-only, or limit it to the projects that agent should see.
Coding-agent plugins
Plugins for Claude Code and Codex brief each session from memory and save a checkpoint before context is compacted.
Agents that run agents
Over MCP, your own agent can write a Basic Memory agent, start runs, check their status, and review finished work.
Give your knowledge a helping hand.
Agents are included on every paid plan. Start with a ready-made one, watch what it does, and keep only the work you want.