How to Build an Obsidian Brain for Your AI Agents: Memory, Dashboards, Morning Briefings, and Controlled Write-Back

Why agents need memory before tools

Most people use AI without memory. They open Claude, ChatGPT, Claude Code, or another assistant, paste context, explain the project, ask for help, copy the answer somewhere else, and repeat the same ritual the next day. The assistant may be smart, but it does not know the state of the work before the conversation starts.

The instinct is to give agents tools first. Connect Gmail, Slack, Notion, GitHub, Linear, Google Calendar, the browser, and the file system. Then hope the agent becomes useful. That order is wrong.

Tool access gives the agent hands, but memory gives it judgment. Without memory, an agent can still do things, but it does not know which things matter, what already happened, what the current priorities are, or which constraints apply. A useful agent needs to answer basic questions before it acts:

This is why Obsidian is valuable. If structured properly, it becomes a readable map of your work — not just a place to store notes, but a first brain the agent reads before it acts. The principle is simple: do not ask the agent to reconstruct your world from a prompt. Give it a world it can read.

Why Obsidian works well as agent memory

Obsidian has several advantages for agent memory that make it worth choosing over a closed workspace or proprietary tool.

Notes are local Markdown files. An agent, script, or terminal tool can read them without a complicated API. A folder of Markdown files is much easier for agents to inspect than a closed workspace full of proprietary objects.

Obsidian supports links and backlinks. This lets you create a graph of people, projects, meetings, decisions, and tasks. Agents do not only need text — they need relationships between pieces of context.

Obsidian supports properties. These are structured fields at the top of notes. A project note can have status, priority, deadline, and next_action. A person note can have last_contact, relationship, and next_touchpoint. Once those fields exist, the vault becomes queryable.

Plugins like Dataview turn the vault into a lightweight database. Dataview is a live index and query engine for Obsidian that lets you add metadata to notes and query it with Dataview Query Language. It keeps queries up to date as notes change.

Obsidian remains under user control. For personal agent memory, that matters. The assistant may eventually read your projects, private notes, relationships, client context, daily logs, and transcripts. Keeping that memory in a local-first system gives you more control than storing everything inside a black-box chatbot history.

Obsidian lists Sync at $4/month billed annually ($5/month monthly) and Publish at $8/month billed annually ($10/month monthly). The core app is free without limits. For an agent memory setup, most users only need the free app plus the free Dataview plugin.

Obsidian requires discipline. If your notes are inconsistent, the agent inherits that inconsistency. If you never update project status, your dashboard lies. But if you design the vault deliberately, it becomes one of the best personal memory layers for AI agents.

The architecture: raw capture, structured memory, dashboard, briefing

An Obsidian agent brain should not be one big folder of notes. A transcript is not the same as a decision. A daily note is not the same as a task. A dashboard is not the same as a project file. The structure should separate different levels of context:

This separation matters. If everything stays as raw capture, agents have to do too much excavation. If everything becomes rigid structure, the system becomes annoying to maintain. Let raw capture exist, but gradually extract useful context into structured notes.

The agent should be able to move across layers: read a transcript, extract a decision, update a project note, create an open loop, and mention the result in tomorrow's briefing. That is how memory becomes operational.

The vault structure

A good agent-readable vault needs simple folders with clear jobs. Avoid building a system so complex that you abandon it after a week. A practical structure:

AI-Agent-Brain/
├── 00 - DASHBOARD/
├── 01 - DAILY/
├── 02 - PROJECTS/
├── 03 - PEOPLE/
├── 04 - TASKS/
├── 05 - MEETINGS/
├── 06 - DECISIONS/
├── 07 - TRANSCRIPTS/
├── 08 - RESEARCH/
├── 09 - BRIEFINGS/
├── 10 - TEMPLATES/
└── 99 - ARCHIVE/

Create it from the terminal:

mkdir -p "AI-Agent-Brain"/{"00 - DASHBOARD","01 - DAILY","02 - PROJECTS","03 - PEOPLE","04 - TASKS","05 - MEETINGS","06 - DECISIONS","07 - TRANSCRIPTS","08 - RESEARCH","09 - BRIEFINGS","10 - TEMPLATES","99 - ARCHIVE"}

Then open AI-Agent-Brain as an Obsidian vault. Each folder has a distinct role:

The folder names are less important than the separation of roles. If the agent needs current project state, it goes to 02 - PROJECTS. If it needs yesterday's unfinished items, it goes to 01 - DAILY. If it needs relationship context, it goes to 03 - PEOPLE.

Install Obsidian

Obsidian is available for macOS, Windows, Linux, iOS, and Android. For most users, install it from the official site, create or open a vault, and point it to the folder structure above. Enable community plugins when you are ready to add Dataview.

On Linux, you can also install via Snap:

sudo snap install Obsidian --classic

For a local-first agent brain, the important thing is not how you install Obsidian — it is that the vault is just a folder of Markdown files your tools can read directly.

Pricing: what this setup costs

The core Obsidian app is free without limits. You do not need an account to use a local vault. The optional paid parts are about syncing, publishing, and commercial use.

For an agent-memory setup, most people can start with the free app and the free Dataview plugin. Pay for Sync if you want official multi-device sync with less setup. Pay for Publish only if you want to turn some notes into a public site.

Install Dataview

Dataview is the plugin that makes the dashboard useful. Without it, Obsidian is still a good memory system, but the dashboard will be mostly manual. With Dataview, the dashboard reads notes and updates itself automatically.

Install it inside Obsidian:

1. Open Settings.
2. Go to Community plugins.
3. Turn off Restricted mode.
4. Click Browse.
5. Search for Dataview.
6. Install and enable it.

Dataview is a live index and query engine over your knowledge base. It lets you add metadata to notes and query that metadata to list, filter, sort, or group information. Once enabled, any note can contain a Dataview query block that auto-updates as your vault changes.

The note templates

The system works only if notes have consistent structure. Each note type should have a small set of fields that remain consistent. Avoid the temptation to model everything — you want enough structure for agents and dashboards, but not so much that writing a note becomes a tax.

---
type: project
status: active
priority: high
deadline: 2026-06-15
owner: Vincent
next_action: Draft the article intro
completion: 40
related_people:
  - Sarah
  - Alex
---

# Project Name

## Goal
What this project is supposed to achieve.

## Current state
Where things stand right now.

## Constraints
Important limits, dependencies, risks, or decisions.

## Notes
Useful context for the project.

---
type: person
relationship: investor
status: active
last_contact: 2026-05-18
next_touchpoint: 2026-05-25
priority: high
context: Interested in AI Career
---

# Person Name

## Context
Who they are and why they matter.

## History
Important interactions, conversations, or commitments.

## Preferences
Communication style, interests, boundaries, or useful details.

## Next touchpoint
What should happen next.

---
type: task
status: in-progress
project: AI Career
due: 2026-05-22
priority: high
energy: deep
---

# Task Name

## Outcome
What done looks like.

## Notes
Context, links, blockers, or requirements.

---
type: meeting
date: 2026-05-22
project: AI Career
people:
  - Sarah
  - Alex
status: processed
---

# Meeting with Sarah and Alex

## Summary
Short summary of the conversation.

## Decisions
- Decision 1
- Decision 2

## Action items
- [ ] Action item 1
- [ ] Action item 2

## Follow-up
What needs to happen next.

---
type: decision
date: 2026-05-22
project: AI Career
status: decided
impact: high
---

# Decision: Use Obsidian as the agent memory layer

## Context
What led to this decision.

## Options considered
- Option A
- Option B
- Option C

## Decision
What was chosen.

## Why
The reasoning behind the choice.

## Revisit if
Conditions that would change the decision.

---
type: daily
date: 2026-05-22
focus: Finish Obsidian agent memory article
energy: medium
---

# 2026-05-22

## Focus
The main thing that matters today.

## Plan
- [ ] First important task
- [ ] Second important task
- [ ] Third important task

## Open loops
OPEN: Follow up on the contractor stack article visual.
OPEN: Decide whether to turn the Obsidian article into a setup guide.

## End of day
What changed today.

The dashboard should read, not store

This is the most important design principle in the whole system. A dashboard is not another place to put information. It is a note that reads from the rest of the vault and surfaces what matters right now.

If the dashboard becomes a manual note, it will rot. If it reads from project notes, task notes, people notes, and daily notes, it stays current as long as the underlying notes are current.

Create the file:

touch "AI-Agent-Brain/00 - DASHBOARD/Dashboard.md"

Then add sections with Dataview queries. Place each query inside a Dataview code block in your Obsidian note.

Today's priorities

TABLE WITHOUT ID
  file.link AS "Task",
  due AS "Due",
  project AS "Project",
  priority AS "Priority"
FROM "04 - TASKS"
WHERE type = "task"
AND status != "complete"
AND (due = date(today) OR due < date(today))
SORT priority DESC, due ASC
LIMIT 10

The LIMIT 10 is intentional. A dashboard that shows 47 overdue tasks does not create clarity — it creates anxiety.

Active projects

TABLE WITHOUT ID
  file.link AS "Project",
  priority AS "Priority",
  completion + "%" AS "Done",
  deadline AS "Deadline",
  next_action AS "Next Action"
FROM "02 - PROJECTS"
WHERE type = "project"
AND status = "active"
SORT priority DESC, deadline ASC

The most important column is next_action. An agent should never have to guess what moves a project forward.

Upcoming deadlines

TABLE WITHOUT ID
  file.link AS "Item",
  type AS "Type",
  deadline AS "Deadline",
  status AS "Status"
FROM ""
WHERE deadline >= date(today)
AND deadline <= date(today) + dur(7 days)
AND status != "complete"
SORT deadline ASC

This catches any note with a deadline field — projects, deliverables, decision notes, or other structured files.

People to contact

TABLE WITHOUT ID
  file.link AS "Person",
  relationship AS "Relationship",
  last_contact AS "Last Contact",
  next_touchpoint AS "Next Touchpoint",
  priority AS "Priority"
FROM "03 - PEOPLE"
WHERE type = "person"
AND status = "active"
AND next_touchpoint <= date(today)
SORT priority DESC, last_contact ASC

This turns relationship memory into action. The assistant should not only remember tasks — it should remember people.

Open loops from yesterday

Use the OPEN: convention in daily notes for items that should carry forward:

LIST
FROM "01 - DAILY"
WHERE type = "daily"
AND date = date(today) - dur(1 day)
FLATTEN file.lists AS item
WHERE contains(string(item), "OPEN:")

Open loops are not always formal tasks. They are often small unresolved items that disappear if you do not create a system for them.

Recent decisions

TABLE WITHOUT ID
  file.link AS "Decision",
  project AS "Project",
  date AS "Date",
  impact AS "Impact"
FROM "06 - DECISIONS"
WHERE type = "decision"
AND date >= date(today) - dur(14 days)
SORT date DESC

This lets the agent understand recent strategic context before acting.

Stale projects

TABLE WITHOUT ID
  file.link AS "Project",
  priority AS "Priority",
  deadline AS "Deadline",
  next_action AS "Next Action"
FROM "02 - PROJECTS"
WHERE type = "project"
AND status = "active"
AND (next_action = null OR completion < 100)
SORT deadline ASC

You can improve this later by adding a last_reviewed field to project notes.

The morning briefing workflow

The dashboard shows data. The briefing explains what the data means. This is where the agent becomes useful. You do not want a model to repeat the dashboard back to you — you want it to synthesize the situation.

A good morning briefing prompt:

Read my Obsidian dashboard note and every file it references.

Synthesize a morning briefing that tells me:
1. The single most important thing to accomplish today.
2. What requires my attention before noon and why.
3. What is at risk if I do not act on it today.
4. Which person or relationship most needs attention.
5. One decision sitting open that I should make before I start.

Do not describe the tables. Tell me what they mean.
Keep the briefing under 300 words.
Start with the most urgent thing.

The instruction "do not describe the tables" is important. Many assistants will summarize visible data instead of interpreting it. The point of the briefing is to turn memory into judgment, not to recap the dashboard.

Save the output into:

AI-Agent-Brain/09 - BRIEFINGS/2026-05-22 - Morning Briefing.md

Or append it to today's daily note in 01 - DAILY.

Connecting Claude Code to the vault

Claude Code is an agentic coding tool that lives in the terminal, understands your codebase, and helps execute routine tasks across files and tools. It can operate inside your vault folder and read or update Markdown files directly.

Install Claude Code with the official native installer on macOS, Linux, or WSL:

curl -fsSL https://claude.ai/install.sh | bash

Or with npm (requires Node.js 18 or later):

npm install -g @anthropic-ai/claude-code

Then open your vault directory:

cd ~/AI-Agent-Brain
claude

From there, ask Claude Code to read and update Markdown files:

Read 00 - DASHBOARD/Dashboard.md and the notes linked from it.
Create today's morning briefing in 09 - BRIEFINGS using this format:
- Most important priority
- Before-noon attention
- Risk if ignored
- Relationship to contact
- Decision to make

Then append a one-paragraph summary to today's daily note in 01 - DAILY.
Do not modify project notes unless you ask first.

The rule "do not modify project notes unless you ask first" matters because Claude Code can edit files. Being explicit about what it can and cannot change prevents unintended rewrites. This is where the CLAUDE.md rules file becomes essential.

Add a CLAUDE.md rules file

A rules file tells the agent how to behave in the vault. It prevents each session from becoming a new negotiation about what the agent can touch. Create it at the vault root:

touch "AI-Agent-Brain/CLAUDE.md"

Add the following content:

# CLAUDE.md

You are working inside an Obsidian vault used as an AI-agent memory system.

## Core rules
- Read relevant notes before making recommendations.
- Prefer updating existing notes over creating duplicates.
- Do not delete notes unless explicitly instructed.
- Do not rewrite entire notes unless asked.
- When creating new notes, use the templates in 10 - TEMPLATES.
- Preserve YAML frontmatter.
- If a field is missing, ask before inventing it.
- Add important unresolved items as OPEN: lines in the relevant daily note.
- Write decisions into 06 - DECISIONS when a meaningful choice is made.
- Keep generated briefings under 300 words unless asked otherwise.

## Folder roles
- 00 - DASHBOARD: overview and control panels.
- 01 - DAILY: daily notes and open loops.
- 02 - PROJECTS: project state and next actions.
- 03 - PEOPLE: relationship memory.
- 04 - TASKS: task notes.
- 05 - MEETINGS: meeting notes and summaries.
- 06 - DECISIONS: decision logs.
- 07 - TRANSCRIPTS: raw transcripts and capture.
- 08 - RESEARCH: external research.
- 09 - BRIEFINGS: generated summaries.
- 10 - TEMPLATES: note templates.
- 99 - ARCHIVE: inactive material.

## Safety
- Ask before making large structural changes.
- Ask before moving files.
- Ask before changing more than five notes at once.
- Summarize every edit you make.

This file turns the vault into a controlled workspace. The agent is not just reading random notes — it is operating inside defined rules.

Connect the vault through MCP

For more advanced setups, MCP (Model Context Protocol) can connect agents to local tools and data sources. Claude Code supports connecting to external tools through MCP, which Anthropic describes as an open standard for AI-tool integrations. The simplest path is still to let Claude Code operate directly inside the vault folder — that is enough for most users.

A more advanced path is to expose the vault through a filesystem MCP server:

npx -y @modelcontextprotocol/server-filesystem ~/AI-Agent-Brain

Then configure the client to use that filesystem server. The exact configuration depends on the client — Claude Desktop, Claude Code, Cursor, Windsurf, or another MCP-compatible tool.

The safety point is critical: do not expose your entire home directory to an agent. Expose only the vault folder, and preferably start with read-only workflows if your client supports it.

Git backup and versioning

Obsidian Sync gives you official sync and version history, but some technical users also prefer Git. Git versions Markdown files cleanly and gives you a full audit trail. Inside the vault:

cd ~/AI-Agent-Brain
git init
git add .
git commit -m "Initial Obsidian agent brain setup"

Add a .gitignore:

.Obsidian/workspace*
.Obsidian/cache
.trash/
.DS_Store

Commit regularly:

git add .
git commit -m "Update projects and daily notes"

To push to a private GitHub repository:

git remote add origin [email protected]:YOUR_USERNAME/ai-agent-brain.git
git branch -M main
git push -u origin main

Do not put sensitive notes into a public repository. If the vault contains people notes, client information, transcripts, business plans, or private decisions, treat it like confidential infrastructure.

The write-back loop

Reading is only half the system. The agent also needs to write back. If it only reads the vault, the vault drifts from reality. If it writes carelessly, the vault becomes noisy. A good write-back loop updates memory after work happens.

A simple write-back convention in daily notes:

DONE: AI Career article draft completed.
UPDATE: AI Career — completion: 70
OPEN: Choose visual for Obsidian agent memory article.
DECISION: Use "Obsidian as first brain for agents" as the article angle.

Then an agent can process the daily note and update relevant files:

Read today's daily note.
Process lines starting with DONE, UPDATE, OPEN, and DECISION.
- For DONE lines, update matching task notes if obvious.
- For UPDATE lines, update the matching project note.
- For OPEN lines, keep them in the daily note and include in tomorrow's briefing.
- For DECISION lines, create a decision note in 06 - DECISIONS.

Before editing, show me the changes you plan to make.

The "before editing" clause is a safety layer. Once the workflow is reliable, some low-risk updates can become automatic.

Transcripts: raw memory without drowning the vault

Transcripts are powerful but dangerous. If you dump every meeting, voice memo, and call into Obsidian without processing, the vault becomes heavy and noisy. Use 07 - TRANSCRIPTS for raw material, but extract useful context into structured notes.

A transcript processing prompt:

Read this transcript.

Create:
1. A five-bullet summary.
2. A list of decisions.
3. A list of action items.
4. People mentioned.
5. Projects mentioned.
6. Open loops.
7. Any updates that should be made to project notes or people notes.

Do not update files yet. First show me the proposed changes.

After review, ask the agent to write a meeting note in 05 - MEETINGS, a decision note in 06 - DECISIONS if needed, updates to relevant project notes, and OPEN: items in the daily note. This turns transcripts into memory instead of storage.

Research notes: external context that compounds

Agents need internal memory, but they also need fresh external context. If research lives only inside a chat, it disappears. If research becomes a note, it compounds. Use 08 - RESEARCH for tool comparisons, market notes, company research, technical explanations, source summaries, and competitive analysis.

---
type: research
topic: Obsidian agent memory
date: 2026-05-22
status: active
source_quality: mixed
related_project: AI Career
---

# Research: Obsidian agent memory

## Summary
What matters.

## Key findings
- Finding 1
- Finding 2
- Finding 3

## Sources
- Source 1
- Source 2

## Implications
What this changes.

## Follow-up
What to investigate next.

Research should always link back to projects and decisions. Otherwise, it becomes a library nobody uses.

A 30-day implementation plan

Do not build the whole system in one afternoon. Build the minimum version, use it, then add structure where it creates value.

Common mistakes

1. Overbuilding the taxonomy

A giant vault taxonomy feels productive but usually collapses. Start with the smallest structure that supports your actual work.

2. Inconsistent properties

If some project notes use deadline, others use due, and others use target_date, your queries will break. Choose field names and stick to them.

3. Making every thought a task

Not everything belongs in a task system. Some items are open loops, some are decisions, some are notes, and some are raw context.

4. Dumping transcripts without processing

Raw capture is useful only if important context is extracted into structured memory.

5. Letting agents edit too much too soon

Start with read-only analysis, then draft-only changes, then approved write-back. Full autonomy should be earned, not assumed.

6. Confusing dashboard data with judgment

The dashboard shows what exists. The briefing explains what it means.

The minimum viable Obsidian agent brain

The smallest useful setup is not complicated. You need: one Obsidian vault, folders for daily notes, projects, people, and tasks, a dashboard, Dataview, a morning briefing prompt, a cautious agent connection, and a rule that important outputs get written back.

A minimum command-line setup:

mkdir -p "AI-Agent-Brain"/{"00 - DASHBOARD","01 - DAILY","02 - PROJECTS","03 - PEOPLE","04 - TASKS","09 - BRIEFINGS","10 - TEMPLATES"}
cd "AI-Agent-Brain"

Then add your first project note to 02 - PROJECTS/AI Career.md:

---
type: project
status: active
priority: high
deadline: 2026-06-15
owner: Vincent
next_action: Draft the Obsidian agent memory article
completion: 20
---

# AI Career

## Goal
Build the best resource for AI jobs, tools, founder resources, and agent workflows.

## Current state
Several articles drafted. Obsidian agent brain article is next.

## Notes
Focus on practical guides, strong visuals, and structured comparisons.

Open the folder in Obsidian, enable Dataview, and the system begins.

Final view

Obsidian is not valuable for agents because it is trendy. It is valuable because it gives agents a durable, readable, structured memory layer that the user owns.

The assistant can only become useful over time if the context survives across sessions. Your projects, people, decisions, meetings, transcripts, open loops, and priorities need to live somewhere outside the chat window. Obsidian is one of the simplest places to put that memory because it is local, Markdown-based, linkable, queryable, and flexible.

The practical path is clear: start with a small vault, add consistent properties, build a dashboard that reads from notes instead of storing information manually, use an agent to generate a morning briefing, then gradually add write-back, transcript processing, research notes, and controlled updates.

The result is not just a better note-taking system. It is a working memory layer for AI agents. That is the real shift: the agent no longer starts from zero. It starts from your world.

Explore the latest AI jobs on AI Careers, or continue learning in our Learn AI section.