Architecting an Agentic Workflow: Engineering a Multi-Agent Personal Assistant System with Claude Code and Obsidian

The transition from using Large Language Models (LLMs) as simple chat interfaces to deploying them as autonomous personal assistants requires a fundamental shift in system design. It is no longer about crafting the perfect prompt; it is about engineering "skills"—reproducible, automated workflows that leverage agentic reasoning to handle high-frequency, low-decision-making tasks.

By integrating Claude Code with external APIs, cloud-hosted microservices, and a structured knowledge graph in Obsidian, I have developed a system capable of automating approximately 5 to 10 hours of manual labor per week across three primary domains: Productivity & Sales, Research, and Content Engineering.

The Three Pillars of Agentic Automation

To build an effective "Claude OS," one must categorize tasks into buckets based on their cognitive load and decision-making requirements. My architecture focuses on automating "drudgery"—tasks that are repetitive but require high precision.

1. Productivity & Sales: Automated Email Triage and Lead Qualification

The first layer of the system is an Email Triage Automation triggered via a local routine within Claude Code at 08:00 daily. Using the Gmail API/connector, the agent parses all incoming mail from the previous 24-hour window. The core logic involves a classification engine that sorts emails into specific buckets: Leads, Urgent, Warm, Sponsors, Meetings, and Noise.

The complexity lies in the downstream execution for high-value buckets:

• Sponsor Management: For identified sponsors, Claude executes a predefined skill to draft a response containing boilerplate pricing and links to my media kit.
• Lead Qualification Pipeline: This is a multi-step agentic workflow. Upon identifying a Lead, Claude Code extracts metadata (budget, timeline, requirements) from the email body or linked web forms. If the lead meets specific heuristic thresholds (e.g., budget alignment), the agent initiates a secondary Web Search task to perform company reconnaissance. The final output is a structured Markdown report deposited into my Obsidian vault, providing a recommendation: Proceed or Skip.

Furthermore, I have automated the post-discovery call workflow. By integrating Calendly summaries with Claude Code, the system parses meeting recaps and triggers a document generation pipeline. This pipeline generates a branded PDF (detailing Scope of Work, pricing, and signature fields), uploads it to Google Drive, and drafts a follow-up email containing the link.

2. Research: Multi-Source Intelligence Gathering

The research architecture is designed to solve the "information overload" problem by transforming raw data streams into synthesized intelligence. My setup utilizes three primary sources: GitHub, X (Twitter), and YouTube.

The Daily Brief & GitHub API Integration

A scheduled routine executes a Daily Brief, querying the GitHub API to identify trending AI repositories. The agent performs targeted queries across several dimensions:

• Top 10 trending repositories for the current week.
• New repositories created within the last 30 days.
• High-growth repositories (velocity metrics) over 24-hour and 30-day windows.

X Pulse via Railway-hosted Microservices

For real-time monitoring of the AI ecosystem, I utilize a specialized application deployed on Railway. This service acts as an asynchronous listener that monitors major AI contributors (e.g., Anthropic, OpenAI). When significant activity is detected, it pushes notifications to my Telegram client, ensuring near-zero latency for critical updates without requiring manual polling of the X timeline.

Deep Research and Adversarial Sub-Agents

For on-demand deep dives, I utilize a "Deep Research" skill characterized by an intensive multi-agent architecture. Unlike standard RAG (Retrieval-Augmented Generation) or simple web browsing, this workflow spawns up to 100 sub-agents performing adversarial information gathering. These agents browse the web, cross-reference findings, and perform iterative synthesis to resolve conflicting data points. While computationally expensive in terms of token consumption, it provides a level of veracity unattainable through single-agent queries.

The YouTube Pipeline & NotebookLM Integration

To ingest video intelligence, I use a custom YouTube Pipeline skill. This agent searches for relevant content, extracts URLs, and passes them to NotebookLM. To bridge the gap between Claude Code and Google’s ecosystem, I utilize the notebooklm-pi CLI, an unofficial API implementation that allows Claude to programmatically trigger synthesis on YouTube transcripts. This offloads the heavy lifting of long-context transcript processing to Google's infrastructure, saving significant token costs on my local instance.

3. Content Engineering: The Human-in-the-Loop Feedback Loop

While AI struggles with "taste," it excels at structural repurposing. My Content Cascade skill runs bi-daily (12:00 and 20:00) to monitor new YouTube uploads. Upon detection, the agent fetches the transcript and executes a transformation pipeline: YouTube Transcript $\rightarrow$ Blog Post $\rightarrow$ LinkedIn Post $\rightarrow$ Tweet.

The critical technical challenge here is voice consistency. To prevent generic outputs, I employ an iterative training methodology. I provide Claude with high-quality examples of my own writing and then "eviscerate" its initial attempts—providing granular, negative feedback on syntax, tone, and rhythm. This iterative loop (Human-in-the-loop) refines the skill's weights/instructions until the output is indistinguishable from manual drafting.

Systemic Organization: The Obsidian Knowledge Graph

An agentic system is only as good as its retrieval mechanism. To prevent "context drift" and manage growing datasets, I use Obsidian as a structured filing cabinet for Claude Code.

I implement a hierarchical structure inspired by the Karpathy method:

1. Raw: Unstructured data dumps (e.g., raw research findings).
2. Wiki: Synthesized, high-level reports and processed intelligence.
3. Output: Finalized assets (e.g., slide decks, finalized proposals).

To optimize for token efficiency and prevent the agent from "getting lost" in large file structures, every subfolder contains an index document. This index acts as a localized table of contents, allowing Claude Code to navigate the vault via targeted lookups rather than expensive, broad-spectrum grep operations across the entire directory.

Conclusion: Observability and Control

The ultimate goal is a unified Command Center. By deploying a web-based dashboard, I gain observability into my system's performance—monitoring token burn, tracking automation success rates, and accessing all synthesized briefs in one interface. When you combine agentic skills with structured knowledge management and robust observability, you move beyond simple AI usage into true autonomous operations.