This is a submission for the Hermes Agent Challenge

A Multi-Agent Hedge Fund Morning Briefing System

Building a morning intelligence system should not require a Bloomberg terminal. What if you had a team of specialized agents that did the legwork before you even woke up?

This blueprint shows how to build that system using the Hermes framework and Claude.

The Problem: 5:00 AM Information Overload

Every morning, portfolio managers stare down a mountain of data. Futures, earnings, SEC filings, macro prints, geopolitical headlines, crypto moves, and sentiment. You have minutes to turn that into actual intelligence.

The old way of doing this is broken. You are either burning out analysts at 4:00 AM, relying on fragile custom scripts, or paying six figures for black-box platforms that don't understand your portfolio. We need an open, coordinated team of specialists that gather and verify information before the opening bell rings.

The Blueprint: Hermes + Claude

The trick is separating the concerns.

• Hermes handles the heavy lifting: orchestration, state management, and tool execution.
• Specialized Agents define what to gather and how to structure it.
• Claude handles the reasoning, synthesis, and writing the final report.

No single agent does everything. No single data source is trusted blindly. The system stays observable and fund-agnostic.

On your side, you build the agent definitions, which include roles, prompt templates, tool bindings, and output schemas, along with the reasoning instructions for Claude. You also handle API configurations like endpoint URLs and auth headers, as well as the structured JSON output schemas that ensure downstream agents can consume the data correctly.

What Hermes Gives You vs. What You Build

Before you start, understand the division of labor. Hermes isn't a library for writing agents from scratch. It's the runtime.

Hermes handles:

• The Workflow: Parallel execution, dependency graphs, retries, and timeouts.
• The Runtime: Managing agent lifecycles, state, and message routing.
• The Registry: Connecting tools, auth headers, rate limiting, and caching.
• Observability: Keeping execution traces and logs so you can debug failures.

You build:

• The Definitions: Roles, prompt templates, tool bindings, and output schemas.
• The Prompts: The actual reasoning instructions for Claude.
• The Config: API endpoints and auth.
• The Schemas: The JSON structure agents must return so the next agent can read it.

You don't write a market_agent.py full of requests calls and retry logic. You write a YAML definition that says: "This agent uses the Alpha Vantage tool, runs this prompt, and returns this schema."

The Workflow

The morning briefing is a three-phase Hermes workflow. You don't write complex Python asyncio code, you declare the workflow topology, and Hermes executes it.

Phase 1: Parallel Intelligence Gathering
All data agents launch at once.

Phase 2: Cross-Validation & Risk
Once Phase 1 finishes, Hermes feeds that context into a second wave of agents. They analyze the impact, assess risk, and spot opportunities.

Phase 3: Synthesis & Distribution
A single agent gathers all inputs and hands them to Claude to generate the final report. This gets sent to Slack, Email, or PDF.

Agent Definitions: The "Real" Work

In Hermes, an agent is just config plus a prompt. Here is how a MarketAgent looks:

name: market_agent
model: claude-sonnet-4
tools:
  - name: alpha_vantage
    config:
      api_key: ${ALPHAVANTAGE_API_KEY}
      endpoints: [global_quote, treasury_yield]
prompt: |
  You are the Market Agent. Use your tools to gather:
  - S&P 500, Nasdaq, and 10Y Treasury yield
  - DXY, VIX, Gold, and Oil
  - Bitcoin and Ethereum
  Return JSON with market sentiment, top movers, and key levels.
output_schema: schemas/market_data.json

Hermes calls the APIs, handles retries, caches responses, and validates the output. You focus on the prompt and the logic of what matters.

Why This Architecture Works

The most important design choice is that Claude does not gather data. Claude only reasons.

When you ask an LLM to browse the web, interpret data, and write a summary, you get hallucinations. By forcing agents to retrieve data first and return structured JSON, you turn Claude into a focused strategist. It only works with verified, structured intelligence.

Repository Structure

Because Hermes handles the runtime, your repository is mostly configuration, prompts, and schemas:

hedge-fund-briefing/
├── agents/
│   ├── market_agent.yaml
│   ├── news_agent.yaml
│   ├── macro_agent.yaml
│   ├── earnings_agent.yaml
│   ├── filing_agent.yaml
│   ├── sentiment_agent.yaml
│   ├── research_agent.yaml
│   ├── risk_agent.yaml
│   └── opportunity_agent.yaml
├── workflows/
│   └── morning_briefing.yaml
├── prompts/
│   ├── synthesis.txt
│   ├── sentiment.txt
│   └── opportunities.txt
├── schemas/
│   ├── market_data.json
│   ├── headlines.json
│   └── risk_assessment.json
├── tests/
│   └── agent_validation/
├── .env
├── docker-compose.yml
└── README.md

Notice: no tools/ folder. Hermes provides the tool registry. You configure tool bindings in the agent YAMLs, not write HTTP clients.

Implementation Roadmap

Build this in phases.

1. Core Loop: Get the market, news, and macro agents running. Create the synthesis prompt and pipe it to Slack.
2. Intelligence Layer: Add the earnings, filing, and sentiment agents. Integrate your portfolio data for impact analysis.
3. Alpha Layer: Add risk and opportunity agents. Start generating PDF reports.
4. Institutional Hardening: Add Redis for caching, PostgreSQL for historical storage, and RAG over past briefings to look for patterns.

Conclusion

This architecture is built to grow.

• Need an Insider Trading Alert agent? Just register a new tool binding for SEC filings.
• Want a Voice Briefing? Add an ElevenLabs tool to turn the report into a podcast.
• Need Historical RAG? Search over your past briefings to ask: "When was the last time the VIX spiked 20% before a Fed meeting?"

The architecture is designed to absorb new intelligence sources without structural changes:

• Options Flow Agent: register unusual_whales tool binding
• Insider Trading Alert Agent: a real-time Form 4 monitoring via sec_edgar
• Geopolitical Risk Agent: satellite imagery + shipping data tools
• Quant Signal Agent: proprietary factor integration via custom tool binding
• Voice Briefing Agent: ElevenLabs text-to-speech tool for podcast generation
• Historical RAG Agent: vector search over past briefings: "When was the last time VIX spiked 20% before a Fed meeting?"

This framework lets you think in teams of specialists. No single model can capture the complexity of global markets, but a coordinated swarm of agents, orchestrated by Hermes and reasoned over by Claude gets surprisingly close.

This blueprint is open, extensible, and designed to be implemented in phases. The custom code is minimal because Hermes handles the orchestration, tool execution, and state management. What you bring is the domain expertise: the prompts, the schemas, and the understanding of what matters before market open.

What do you think? Would you structure your agents differently, or are there data sources you'd add immediately? I would appreciate feedback on what you think should be added.