Your phone knows things your dev machine doesn't. Obsidian synced vaults let you drop context from anywhere — a meeting, a commute, a conversation — and have it waiting when you sit down to code. Here's how to wire it up so your AI agent inherits that context automatically.
AI agents like Claude Code are powerful but session-scoped. Every time you open a new terminal, the agent starts fresh. It doesn't know what you decided in that meeting yesterday, what the client said on the phone, or what you figured out on the train.
You could paste things manually every session. Or you can build a bridge: notes you write anywhere flow into your vault, your vault feeds your agent, and your agent arrives at the keyboard already knowing the things you've told it.
The vault is the shared state between your brain (on whatever device) and your agent (in the terminal).
Obsidian stores everything as plain markdown files. This is the key property. Your agent can read markdown files directly — no API, no integration layer, no export step. The vault is just a folder of text files that Claude Code can cat, search, and reason over directly.
| Property | Why it matters for AI |
|---|---|
| Plain markdown files | Agent reads them natively — no conversion needed |
| Local-first storage | Files live on disk, agent can grep/read the whole vault |
| Sync across devices | Notes written on phone appear on dev machine automatically |
| Bidirectional links | Agent can navigate the knowledge graph with plain text [[links]] |
| Folder structure | You control the taxonomy — agent can be pointed at specific folders |
Obsidian doesn't sync by default — you need to pick a sync method. Three practical options:
The easiest path. End-to-end encrypted, works on iOS, Android, desktop. ~$10/month. Worth it if you're already paying for Obsidian and want zero configuration.
Point Obsidian at a folder inside your cloud drive. Free, works across Apple or Google ecosystems. Sync latency is a few seconds to a minute — fine for context notes, not great for real-time collaboration.
Syncthing is a peer-to-peer sync daemon — your phone and dev machine sync directly when on the same network, or via a relay server when remote. Zero cloud dependency. The Remotely Save Obsidian plugin adds S3, Dropbox, or WebDAV as sync targets. Good choice if you want full data sovereignty.
A flat dump of notes is readable but noisy. A little folder structure makes it much easier to point the agent at the right thing without it having to read everything.
vault/ ├── Inbox/ ← mobile quick-drops, unsorted thoughts ├── Daily/ ← daily notes (YYYY-MM-DD.md) ├── Projects/ ← one folder per project │ ├── MyApp/ │ │ ├── decisions.md │ │ ├── todo.md │ │ └── meeting-notes/ ├── Context/ ← persistent facts the agent should know │ ├── people.md ← who's who on projects │ ├── constraints.md ← hard requirements, deadlines, non-negotiables │ └── stack.md ← current tech decisions └── Research/ ← reference material
The Context/ folder is the most important for agent use. These are the facts you want available every session — not ephemeral notes, but stable knowledge.
On mobile, friction is the enemy. Make the Inbox the zero-thought drop zone. Voice transcription, quick bullets, half-formed thoughts — all goes here. You process it into the right place later, or point the agent at the Inbox to help you process it.
talked to client today — they want the dashboard to support CSV export by end of month. deadline is hard. also mentioned they're moving to annual billing which affects the subscription module. check with Tom about the data model before we touch that.
That note, once synced, is immediately available to the agent. No copy-paste needed.
The simplest integration. At the start of a session, tell the agent:
"Check ~/Documents/my-vault/Inbox/ and ~/Documents/my-vault/Projects/MyApp/ for recent context before we start."
Claude Code will read the relevant files and incorporate them. Simple, zero setup, works today.
Add a block to your project's CLAUDE.md that tells the agent where to look for vault context:
# Context Sources Check these vault paths for relevant context at session start: - ~/Documents/my-vault/Projects/MyApp/decisions.md - ~/Documents/my-vault/Projects/MyApp/todo.md - ~/Documents/my-vault/Inbox/ (recent mobile drops — check timestamps) If a note is in Inbox and clearly relates to this project, incorporate it and flag it for filing.
Now every Claude Code session in that project directory automatically picks up vault context without you having to ask.
The most seamless approach. A UserPromptSubmit hook reads your vault's Daily note and Inbox, extracts anything recent, and prepends it to every prompt automatically.
// ~/.claude/settings.json
{
"hooks": {
"UserPromptSubmit": [
{
"matcher": "",
"hooks": [
{
"type": "command",
"command": "~/.local/bin/vault-context-inject.sh"
}
]
}
]
}
}
#!/bin/bash
# vault-context-inject.sh
# Injects today's vault context as a system hint
VAULT="$HOME/Documents/my-vault"
TODAY=$(date +%Y-%m-%d)
DAILY="$VAULT/Daily/$TODAY.md"
INBOX="$VAULT/Inbox"
echo "=== Vault Context ==="
if [ -f "$DAILY" ]; then
echo "--- Today's notes ($TODAY) ---"
cat "$DAILY"
fi
# Any inbox files modified in the last 24 hours
RECENT=$(find "$INBOX" -name "*.md" -newer "$VAULT/.last-inject" 2>/dev/null)
if [ -n "$RECENT" ]; then
echo "--- Recent Inbox drops ---"
echo "$RECENT" | xargs cat
fi
touch "$VAULT/.last-inject"
Auto-creates a dated note each day. Your mobile app opens straight to it. Good home for stream-of-consciousness context.
Sync vault to S3, Dropbox, or WebDAV. Good if you want sync without paying for Obsidian Sync.
Auto-populates new notes with frontmatter tags. Useful for tagging notes by project so they're easier to filter for the agent.
Query your notes like a database. Less relevant for agent use, but good for building your own dashboards across projects.
Record voice, transcribe to text in the Inbox. Fastest possible context drop — speak a thought, it lands as text in the vault.
Extends daily notes to weekly and monthly. Useful for capturing longer-term project state that the agent should inherit.
Here's the end-to-end flow once this is set up:
Beyond daily context, the vault can serve as your agent's long-term memory — things that remain true across projects and time:
This is different from CLAUDE.md, which is code-adjacent instructions. The vault holds the human context behind the work — the why, not the how.
If you run a RAG system (see the Knowledge Graphs guide), your Obsidian vault is an excellent corpus to ingest. A simple cron job can watch the vault for changes and push new/modified notes to your RAG endpoint:
#!/bin/bash
# watch-vault-rag.sh — ingest new vault notes into RAG
VAULT="$HOME/Documents/my-vault"
RAG_ENDPOINT="http://your-rag-server:9990/ingest"
LAST_RUN="$VAULT/.last-rag-ingest"
find "$VAULT" -name "*.md" -newer "$LAST_RUN" | while read -r file; do
title=$(head -1 "$file" | sed 's/^# //')
text=$(cat "$file")
curl -s -X POST "$RAG_ENDPOINT" \
-H "Content-Type: application/json" \
-d "{\"source\": \"obsidian\", \"title\": \"$title\", \"text\": $(echo "$text" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))')}" \
> /dev/null
done
touch "$LAST_RUN"
Run this on a cron schedule (every 15 minutes is fine). New vault notes become queryable by your RAG agent almost immediately. Combined with the hooks pattern, this means notes written on your phone are searchable by AI within minutes.
Obsidian handles context notes. But you can go further — running actual Claude Code sessions, editing code, and managing your entire local dev environment from your phone. The stack for this is Tailscale + a terminal app.
Tailscale creates a private WireGuard mesh between all your devices. Install it on your dev machine and your phone, and they're on the same private network regardless of where either is physically — home, office, cellular, coffee shop. No port forwarding, no dynamic DNS, no VPN server to manage.
Once Tailscale is running, every service on your dev machine is reachable from your phone by its Tailscale IP or hostname:
ssh youruser@your-machine-hostname.tailnet-name.ts.net # or by IP ssh youruser@100.x.x.x
This also makes local services — your dev server on port 3000, your AI tool on port 7860, your local dashboard — accessible from anywhere without exposing them to the internet.
Terminus is an SSH client for iOS with a proper terminal emulator — split views, keyboard shortcuts, persistent sessions, custom key bars, and mosh support for spotty connections. It's the practical choice for doing real work from an iPhone.
Paired with Tailscale:
mosh on the server side and use Terminus's built-in mosh support for uninterrupted sessions.
You're not using a cloud IDE, a remote container, or a stripped-down mobile editor. You're in your actual terminal, on your actual machine, running your actual tools. The phone is just the input/output device.
Combine this with the Obsidian workflow: drop a context note in Obsidian on your phone, switch to Terminus, open Claude Code, and say "check the vault Inbox." The note you wrote 30 seconds ago is already there.
Beyond SSH, Tailscale exposes all your local services to your phone without punching holes in your firewall. If you run:
...all of those are reachable on your phone via http://your-machine.ts.net:PORT. No cloud deployment needed to test something from your phone.
Inbox/, Daily/, and Context/ foldersclaude → confirm full session works