If you've ever tried building a personal knowledge base with neural networks, you've almost certainly fallen into the classic over-engineering trap. After watching a few "second brain" videos, enthusiasts rush to erect monstrous contraptions: spinning up local vector databases, configuring complex graph DBMSs, bolting on dozens of custom plugins, and gluing it all together with brittle scripts. The ending is always the same: one library update breaks the whole rig, and you spend more hours fixing software than you save working.
Engineer and agentic-development educator Cole Medin, creator of the Dynamous learning platform, offered a refreshingly pragmatic way out of this dead end. He showed that a truly reliable AI Second Brain doesn't need heavy machinery—just a plain local folder of Markdown files and a lightweight agent runtime built on the open Model Context Protocol (MCP) and the Arcade platform. This setup handles routine fact-gathering, analytical reporting, and project syncing, freeing up 25 to 30 hours of his workweek.
At the heart of the approach sits an elegant 4C model. Let's walk through all four components and see how to get an agent working smoothly with your personal notes.
Context: Why Plain Markdown Files Beat Databases
The first and most important pillar is Context. Medin insists on ditching closed proprietary formats like Notion databases or specialized binary stores. Your entire knowledge base should be flat Markdown text files sitting in a regular directory on disk (such as an Obsidian vault).
Why does this matter? Plain text doesn't depend on the whims of third-party app developers: it will open on any computer twenty years from now. To help a neural network navigate thousands of those notes instantly, each file follows a strict contract with a unified metadata block (YAML frontmatter).
Here is what a reference project note looks like in this vault:
---
id: project-dynamous-agentic
title: "Applied Agentic Course Architecture — Dynamous"
type: project
status: active
tags: [education, ai-agents, architecture, mcp]
updated_at: 2026-10-29
---
# Applied Agentic Course Architecture — Dynamous
## Project Goals and Key Metrics
- Launch a hands-on Model Context Protocol module for 500 engineers.
- Prepare the `second-brain-starter` base template repository.
## Related Concepts
- See the core protocol spec: [[mcp-core-architecture]]
- Local tool runtime: [[arcade-runtime-setup]]
Thanks to the metadata header, an agent scanning the directory immediately sees a document's status, last-updated date, and category without reading the entire body—saving both time and tokens.
Connections: Two-Tier Navigation Across the Knowledge Graph
The second component is Connections. Isolated notes are dead weight; a knowledge base only pays off when scattered facts link into a bigger picture. Medin uses a two-tier linking mechanic:
- Explicit logical bridges via bidirectional links (Wikilinks): Using
[[Note Name]]syntax lets the agent walk a dependency graph. If you ask the model to draft a course presentation, it spots the link to MCP architecture, follows it, and pulls in related technical specs without needing a separate prompt. - Semantic vector index: To surface non-obvious associations, a lightweight local index (built on SQLite-vec or embedded Chroma) sits on top of the files. Ask a question in plain English, and semantic search pulls relevant passages even when exact keywords don't match.
This hybrid pairs the precision of deterministic links with the associative flexibility of neural search.
Capabilities: Wiring Actionable Tools via Arcade MCP
A passive knowledge base that only answers questions is yesterday's news. The third pillar of the 4C model is Capabilities. To turn a second brain into an active assistant, the agent gets real tools through the Arcade runtime and the open Model Context Protocol (MCP).
Instead of writing bulky custom API glue, Medin plugs in ready-made MCP servers so the agent can take concrete actions in the outside world:
- Search, create, and edit files inside the local notes folder.
- Reach out to the web via search gateways to verify facts and refresh stale info.
- Post generated summaries to team Slack or draft outgoing emails.
Registering tools takes a compact Python snippet hooked into the local process:
from arcade import ToolRuntime, mcp_tool
from pathlib import Path
import yaml
vault_path = Path.home() / "Documents" / "SecondBrain"
@mcp_tool
def update_project_status(note_id: str, new_status: str, summary_entry: str) -> dict:
"""Updates project status in metadata and appends an entry to the event log."""
target_file = None
for file in vault_path.glob("*.md"):
content = file.read_text(encoding="utf-8")
if f"id: {note_id}" in content:
target_file = file
break
if not target_file:
return {"success": False, "error": f"Note with id {note_id} not found"}
parts = target_file.read_text(encoding="utf-8").split("---", 2)
frontmatter = yaml.safe_load(parts[1])
frontmatter["status"] = new_status
frontmatter["updated_at"] = "2026-10-30"
updated_body = parts[2] + f"\n\n### Update ({frontmatter['updated_at']})\n{summary_entry}"
new_content = f"---{yaml.dump(frontmatter)}---{updated_body}"
target_file.write_text(new_content, encoding="utf-8")
return {"success": True, "file": target_file.name, "new_status": new_status}
The agent stops being a passive advisor and becomes an operational assistant that updates documents on its own once tasks wrap up.
Cadence: Routine Maintenance and Automated Vault Evals
The fourth—and most often skipped—component is Cadence. Any knowledge base without discipline eventually turns into a junk drawer: duplicates pile up, links rot, and untagged files vanish.
To prevent that decay, Medin runs two recurring background routines:
- Daily Nightly Audit (Daily Cron): Once a day, a background agent scans every file created or modified in the past 24 hours. It validates YAML structure, flags orphan notes with no incoming links, suggests tags, and compiles a morning changelog.
- Knowledge Evals: Once a week, a suite of twenty calibrating questions runs against the vault ("Which projects are currently active?", "Which model is selected for content generation?", "Where is the starter template repo?"). If adding new notes makes the agent hesitate or hallucinate, that's an early warning: a contradiction crept into the structure, and the links need refactoring.
Cole Medin's 4C model proves a clear point: a digital assistant's reliability comes not from algorithmic complexity, but from clean file architecture. Plain text notes, open protocols, and steady hygiene beat closed commercial ecosystems every time.

