Agentic Copilot Review: Claude Code Inside Obsidian

TL;DR

Agentic Copilot is an open-source Obsidian plugin that brings your existing AI coding agents — Claude Code, OpenCode, Gemini CLI, or any custom binary — directly into Obsidian’s sidebar. Key facts:

Open source (MIT licensed), completely free
Agent-agnostic: connects to Claude Code, OpenCode, Gemini CLI, or any custom CLI tool
Zero configuration: auto-detects installed agents on your PATH
Vault-aware context: automatically includes your active file and selection in every prompt
Inline diffs: file edit suggestions appear with Accept/Reject buttons
Multi-session: run multiple independent chat panels with different agents
Slash commands: autocompletes agent-native commands like /commit, /compact, /review-pr
Desktop only: requires Obsidian ≥ 1.5.0

If you use Obsidian for notes and Claude Code for coding, this plugin eliminates the context switch between them. Your knowledge base becomes your AI workspace.

Quick Reference

Field	Value
Repo	spencermarx/obsidian-ai
License	MIT
Install	Community Plugins → “Agentic Copilot” (or BRAT)
Requires	Obsidian ≥ 1.5.0, desktop only
Supported Agents	Claude Code, OpenCode, Gemini CLI (planned), any custom binary
Author	Spencer Marx

What Is Agentic Copilot?

Most Obsidian AI plugins ship their own LLM integration — they bundle API calls, model selection, and authentication directly into the plugin. This creates lock-in. When you want to switch models or providers, you’re reconfiguring plugin settings, managing separate API keys, and often losing features that only work with specific backends.

Agentic Copilot takes a fundamentally different approach. It doesn’t talk to any LLM directly. Instead, it spawns the CLI tools you already have installed — Claude Code, OpenCode, or any custom binary — as child processes, pipes your vault context into each prompt, and streams responses back into a chat panel inside Obsidian.

You (Obsidian) <-> Agentic Copilot <-> CLI Agent <-> LLM Provider
                   (this plugin)

This architecture means:

Your existing config just works. Same API keys, same model settings, same tool permissions as your terminal workflow.
Upstream improvements land automatically. When Claude Code ships a new feature, you get it in Obsidian without waiting for a plugin update.
Swapping agents is a single command. No settings migration, no API key juggling.
Your data stays local. Everything flows from plugin to your local CLI tool — no intermediary servers.

The plugin was created by Spencer Marx, who shared it on Hacker News as a Show HN in late March 2026. It’s been posted twice on HN, with the creator noting it saves significant context-switching time for anyone who works in Obsidian and uses AI coding agents.

Why This Matters Now

The convergence of knowledge management and AI coding is happening faster than most people expected. In early 2026, we’ve seen:

Karpathy’s “LLM Wiki” concept — the idea that your personal knowledge base should be readable by both humans and AI agents
The Agent Skills standard emerging across Claude Code, Cursor, Codex, and Windsurf
Multiple competing Obsidian AI plugins (Claudian, claude-obsidian, Agent Client) all trying to bridge this gap

Agentic Copilot sits right at this intersection. Your Obsidian vault isn’t just notes anymore — it’s context for your AI agents. And instead of copy-pasting between a terminal and your editor, you get a unified interface.

The timing is particularly relevant because Claude Code’s --output-format stream-json mode (which Agentic Copilot uses) has matured enough to support structured streaming — meaning the plugin gets real-time token streaming, tool-use events, and file edit proposals all through a clean JSON protocol.

Key Features Deep Dive

Chat Panel with Real-Time Streaming

The core interface is a sidebar chat panel that renders agent responses using Obsidian’s native Markdown engine. This matters because links, code blocks, callouts, and your theme all render correctly — it’s not a separate rendering engine bolted on.

Responses stream in real-time using the agent’s native streaming protocol. For Claude Code, this means stream-json output format with structured events for text, tool use, and file edits.

Vault-Aware Context Injection

Every prompt automatically includes:

Active file content — whatever document you’re currently editing
Text selection — if you’ve highlighted something specific
Vault path — so the agent knows your project structure

This is configurable. You can set the working directory to vault root or the active file’s parent directory, and toggle active file / selection inclusion independently.

// What the agent sees with each prompt:
{
  "context": {
    "activeFile": "notes/project-alpha/architecture.md",
    "selection": "The caching layer needs to handle...",
    "vaultPath": "/Users/you/obsidian-vault"
  },
  "prompt": "How should I implement this caching strategy?"
}

Inline Diffs with Accept/Reject

When an agent suggests file changes, they don’t just appear as text in the chat. Agentic Copilot parses the edit proposals and shows them as inline diffs with Accept and Reject buttons. No changes are applied to your vault without explicit confirmation.

There’s an “Auto-apply” setting for power users who trust their agent’s edits, but it’s off by default — which is the right default.

Multi-Session Support

You can open multiple independent chat panels, each with its own agent session. Use cases:

Run Claude Code in one panel for coding, OpenCode in another for research
Keep separate conversations for different projects
Compare agent responses side-by-side

The max concurrent sessions defaults to 5, configurable in settings.

Slash Command Integration

Type / in the chat input and you get autocomplete for agent-native commands. For Claude Code, this means /commit, /compact, /review-pr, /help, and the rest. Commands come directly from the connected CLI tool, so they stay in sync automatically.

Right-click any text in Obsidian to get:

Ask Agent — send the selection as a prompt
Explain Selection — get an explanation of highlighted text
Refactor Selection — ask the agent to refactor selected code

These are also available via the command palette (Ctrl/Cmd+P).

Getting Started

Prerequisites

You need at least one supported CLI agent installed:

# Claude Code (recommended)
npm install -g @anthropic-ai/claude-code

# Or OpenCode
curl -fsSL https://opencode.ai/install | bash

Installation

Method 1: Community Plugins (recommended)

Settings → Community Plugins → Browse → search “Agentic Copilot” → Install → Enable.

Method 2: BRAT (for beta/pre-release builds)

Install BRAT
Add beta plugin → enter spencermarx/obsidian-ai

Method 3: Manual

# Download from latest release
cd /path/to/your/vault/.obsidian/plugins/
mkdir agentic-copilot && cd agentic-copilot

# Download main.js, manifest.json, styles.css from:
# https://github.com/spencermarx/obsidian-ai/releases/latest

# Restart Obsidian and enable the plugin

First Run

Click the bot icon in the ribbon, or press Ctrl/Cmd+P → “Agentic Copilot: Open chat panel”
The plugin auto-detects your installed agents
Start chatting — your active file context is included automatically

That’s genuinely it. If you have Claude Code installed and authenticated, there’s nothing else to configure.

Architecture

The plugin follows a clean adapter pattern:

┌──────────────────────────────────────┐
│         Obsidian Plugin              │
│                                      │
│  ┌──────────┐  ┌──────────────────┐  │
│  │Chat View │  │ Editor Actions   │  │
│  │(ItemView)│  │ (context menu,   │  │
│  │          │  │  command palette) │  │
│  └────┬─────┘  └───────┬──────────┘  │
│       │                │             │
│  ┌────▼────────────────▼──────────┐  │
│  │     Session Manager            │  │
│  │  (spawn, lifecycle, streaming) │  │
│  └──────────────┬─────────────────┘  │
│                 │                    │
│  ┌──────────────▼─────────────────┐  │
│  │      Adapter Layer             │  │
│  │  ┌──────────┐  ┌────────────┐  │  │
│  │  │Claude    │  │ OpenCode   │  │  │
│  │  │Code      │  │ (run mode) │  │  │
│  │  │(stream-  │  │            │  │  │
│  │  │ json)    │  └────────────┘  │  │
│  │  └──────────┘                  │  │
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘

Each adapter is a single file. The Claude Code adapter uses --output-format stream-json for structured streaming. The OpenCode adapter uses run mode with text/JSON output. Adding a new agent means writing one adapter file — the plugin’s README walks through the process.

Comparison with Alternatives

Agentic Copilot isn’t the only game in town. Here’s how it stacks up:

Feature	Agentic Copilot	Claudian	claude-obsidian	Agent Client
Approach	CLI bridge	Claude API direct	Claude API direct	CLI bridge
Multi-agent	✅ Any CLI	❌ Claude only	❌ Claude only	✅ Multiple
Streaming	✅ Native	✅	✅	✅
Inline diffs	✅	✅	❌	✅
API key in plugin	❌ Not needed	✅ Required	✅ Required	❌ Not needed
Vault context	✅ Auto	✅	✅	✅
Multi-session	✅ Up to 5	❌	❌	✅
License	MIT	MIT	MIT	MIT

The key differentiator is the architecture. If you’re already paying for Claude Code (or have an Anthropic API key configured for the CLI), Agentic Copilot doesn’t add another API key management layer. Claudian and claude-obsidian require you to configure API credentials separately inside the plugin.

Honest Limitations

No sugarcoating — here’s what you should know:

Desktop only. This spawns CLI processes, so it cannot work on Obsidian mobile. If you need AI on your phone, look elsewhere.
Requires CLI tools installed. If you don’t already use Claude Code or OpenCode from the terminal, this plugin doesn’t simplify onboarding — you need to install and authenticate the CLI tool first.
Gemini CLI support is still “planned.” The README lists it but it’s not shipped yet. If you’re a Gemini user, you’ll need to wait or use the custom adapter.
Community Plugins approval pending. As of April 2026, the plugin is awaiting approval for the Community Plugins directory. You need to install via BRAT or manually for now.
No mobile sync of conversations. Chat sessions live in the desktop process. There’s no persistence layer that syncs conversation history to your vault (though your files obviously sync normally).
Process management overhead. Each chat session spawns a child process. With 5 concurrent sessions, that’s 5 CLI agent processes running. On a machine with limited RAM, this could be noticeable.
No image generation or multimodal input. The plugin focuses on text-based interaction. Image drag-and-drop is supported for context, but there’s no image generation flow.

Who Should Use This

Good fit:

You already use Claude Code or OpenCode from the terminal
You use Obsidian as your primary knowledge base / note-taking tool
You want AI assistance without leaving your notes
You want to avoid managing multiple API keys across plugins

Not a good fit:

You primarily use Obsidian on mobile
You want a turnkey AI experience without installing CLI tools first
You need an AI plugin for non-coding tasks only (there are simpler options)
You want conversation history synced to your vault files

FAQ

Can I use Agentic Copilot with my own fine-tuned model?

Yes, if you can expose it via a CLI tool. The custom adapter supports any binary that accepts stdin and produces stdout. Write a wrapper script, point the plugin at it, and you’re set.

Does it work with Obsidian Sync?

Your vault files sync normally. The plugin itself and its chat sessions don’t sync — they’re local to the desktop process. This means you won’t see chat history on another machine, but your edited files will sync fine.

How does it compare to using Claude Code in a terminal next to Obsidian?

The main advantage is vault-aware context injection. Instead of manually telling Claude Code which file to look at, the plugin automatically includes your active file and selection. The inline diffs also apply changes directly in Obsidian rather than requiring you to switch to a file manager.

Is it safe to use Auto-apply for file edits?

The creator recommends keeping it off. Auto-apply means the agent’s suggested changes are written to your vault files immediately without review. For notes and documentation this might be fine, but for code or important documents, manual review via the diff UI is safer.

Can I use multiple agents in the same session?

Not in the same session, but you can open multiple panels — one per agent. Each panel runs its own independent session with its own agent.

Does it support MCP (Model Context Protocol)?

Not directly. The plugin delegates to your CLI agent, and if your Claude Code installation has MCP servers configured, those will work through the CLI. The plugin itself doesn’t manage MCP connections.

Bottom Line

Agentic Copilot is a clean, well-architected bridge between Obsidian and the AI coding tools you already use. It doesn’t try to be everything — it does one thing (connect your vault to your CLI agent) and does it well.

The “thin orchestration layer” philosophy is smart. Instead of building yet another LLM integration that will be outdated in 6 months, it piggybacks on tools that are actively maintained by Anthropic, the OpenCode team, and others. When those tools improve, Obsidian users get the benefits automatically.

If you’re in the overlap of “Obsidian power user” and “Claude Code daily driver,” this is worth installing today. The zero-config experience is real — I was chatting with Claude Code inside my vault within 60 seconds of enabling the plugin.

For the broader Obsidian community, this represents an important trend: your notes are becoming an active workspace for AI agents, not just a passive archive. Agentic Copilot is one of the first plugins to get this right.

Agentic Copilot is MIT licensed and free. The project is on GitHub.