Architecting a Multi-Agent Financial Intelligence System via Markdown-Driven Agentic Workflows in Claude

In the current landscape of Large Language Model (LLM) implementation, most users interact with AI through isolated, single-turn prompts or disconnected chat sessions. This approach is fundamentally flawed for complex business logic; it leads to "context drift," where separate analyses of revenue, expenses, and forecasting eventually diverge into conflicting versions of reality.

To solve this, we can move away from "prompting" and toward "agentic orchestration." By leveraging Claude's ability to process structured text, we can build a multi-agent system comprised entirely of Markdown files. This architecture functions as a decentralized finance department where each agent—Revenue Manager, Spend Manager, Forecast Manager, Reporting Manager, and Coordinator—operates within a strictly defined file-system hierarchy, passing stateful information through an "inbox" pattern.

The Architecture: File-System Based Agentic Workflows

The core innovation of this system is that the "intelligence" does not reside in a complex Python script or a heavy orchestration framework like LangChain; instead, it resides in the directory structure itself. Each agent is encapsulated within its own folder, following a standardized tripartite architecture:

1. instructions/: A Markdown file containing the agent's logic, constraints, and operational parameters.
2. input/: The landing zone for upstream data or previous agent outputs.
3. output/: The destination where the current agent writes its processed results for downstream consumption.

To ensure a "single version of truth" across all agents, we implement a shared/ directory. This contains three critical global state files:

• Company Context: A high-level description of business models (e.'g., retainer tiers) and strategic objectives.
• Assumptions: The primary driver for forward-looking logic (growth targets, hiring plans, renewal rates).
• Calendar: A standardized CSV or Markdown file defining fiscal periods to prevent temporal misalignment between agents.

Agent Specification: The Six-Part Instruction Template

To prevent the "hallucination of logic" common in vague prompting, every agent's instruction file follows a deterministic six-part schema. This ensures that Claude does not improvise but rather executes a predefined computational protocol:

1. Role Ownership: A precise definition of the agent’s domain (e.g., "You own all money-out categories").
2. File References: Explicitly named paths to every file the agent is permitted to read.
3. Data Treatment Rules: Logic for handling anomalies, such as cross-referencing invoice IDs against a client roster or flagging duplicate entries.
4. Calculation Protocols: The exact mathematical formulas required for the role (e.g., calculating margin percentages).
5. Output Specification: A strict definition of the output file's schema, including mandatory column names and data types.
6. Destination Mapping: Explicit instructions on where to write the final payload (the "inbox" of the next agent in the chain).

Orchestration via the Coordinator Agent

The system is triggered by a Coordinator agent. This agent acts as the orchestrator, managing the execution sequence and enforcing operational constraints. The Coordinator's logic includes:

• Sequential Dependency Enforcement: A prohibition against starting an agent until its required upstream input file exists in the directory.
• Error Propagation: An instruction to carry all "flags" (anomalies detected by upstream agents) through to the final report.
• Logic Integrity: A directive to never second-guess the logic of a specialized agent, ensuring that the chain remains unbroken even when errors are identified.

Empirical Validation: Error Detection and Sensitivity Analysis

The robustness of this architecture was tested against 18 months of simulated agency data containing intentional anomalies. The Revenue Manager successfully identified duplicate invoice entries (e.g., Invoice 2026-03-0145) that would typically inflate monthly revenue projections in a standard spreadsheet. Furthermore, the system performed an unprompted aging analysis, flagging $35,500 of unpaid invoices older than 9 months as "at-risk."

The true power of this architecture is revealed during Sensitivity Analysis. Because the Forecast Manager relies on the Assumptions file rather than re-processing raw historical data, we can modify a single variable—such as increasing the quarterly client acquisition rate from one to two—and trigger a partial re-run. The system intelligently bypasses the Revenue and Spend agents (as historicals remain unchanged) and recomputes only the downstream nodes: the Forecast and the Reporting Manager. This results in an instantaneous, mathematically consistent update of projected profit margins and risk rankings.

The Final Layer: Automated Deliverable Generation

The pipeline concludes with a Deck Builder agent. Unlike the analytical agents, this role is strictly prohibited from performing calculations; its sole purpose is data extraction and visualization formatting. It reads the finalized reports and transforms them into presentation-ready Markdown or slide structures.

Crucially, this agent acts as a final QA layer. During testing, it identified and corrected parsing errors caused by inconsistent CSV line endings and adjusted chart types (e.g., switching from lines to bars) to ensure data visibility. This self-correcting mechanism ensures that the final output is not just accurate, but presentation-ready.

Conclusion: The Management of AI Logic

Building an agentic system in Claude is not a coding challenge; it is a management and documentation challenge. The difficulty lies in translating business nuances into unambiguous, plain-English instructions. When implemented with strict file-naming conventions, shared context, and explicit error-handling protocols, this architecture transforms an LLM from a simple chatbot into a highly reliable, automated financial department capable of maintaining complex, multi-variable business models.