Building Agent Swarm CFO for the OWS Hackathon

How I used Open Wallet Standard, Tavily, Bright Data, Featherless, Allium, Uniblock, Zerion, CoinGecko, and x402 framing to build a real operator console for autonomous agent teams.

Most agent demos stop at orchestration. They show multiple bots talking to each other, but they avoid the hard production questions:

• Who holds the wallet?
• Who approves spend?
• What data did the agent rely on?
• What happens when a provider is expensive or disallowed?
• How do you revoke access after a mission ends?

Agent Swarm CFO was built to answer those questions directly.

Product Thesis

Agents need finance controls, not just prompts.

That means:

• scoped wallets
• revocable access
• provider-specific budgets
• audit logs
• source traceability
• explicit payment lanes

Open Wallet Standard is the trust layer that makes this possible.

System Design

OWS Wallet + Policies
        |
        v
Mission Orchestrator
        |
        +--> Tavily (search)
        +--> Bright Data (extraction)
        +--> Featherless (synthesis)
        +--> Allium (wallet balances)
        +--> Uniblock (chain reads)
        +--> Zerion (portfolio mix)
        +--> CoinGecko (market context)
        +--> x402 lane (paid endpoint narrative)

Why OWS Was The Right Primitive

I used the Node SDK directly:

import {
  createWallet,
  createPolicy,
  createApiKey,
  signMessage
} from "@open-wallet-standard/core";

This let us do four important things in-process:

1. Create a real wallet vault for the app
2. Register policies for each agent
3. Issue agent-specific API keys
4. Sign actions without exposing raw keys

The product impact is bigger than the code size. Once the wallet and policy layer exist, every agent action can be treated like a governed treasury action rather than a blind API call.

Live Research Pipeline

The research pipeline has three stages.

1. Tavily for grounded retrieval

const results = await searchAndGround(query, {
  searchDepth: "advanced",
  includeRawContent: true,
  maxResults: 5
});

2. Bright Data for premium extraction

const page = await extractPage(results.results[0].url, {
  render: true,
  markdown: true
});

3. Featherless for synthesis

const comparison = await compareSources(results.results);
const report = await draftReport({
  mission,
  findings
});

This pattern gives you a clean research stack:

• search for candidate sources
• extract high-confidence pages robustly
• synthesize only after evidence is grounded

Financial Enrichment

I added partner integrations that make the product feel like treasury software, not just a research dashboard.

Allium

Used for live wallet balance enrichment.

Uniblock

Used for chain reads via a unified JSON-RPC layer.

Zerion

Used for wallet portfolio composition.

CoinGecko

Used for free public market context and benchmark asset movement.

Together, these integrations make the final report richer and make the treasury screen feel real.

UI Decisions

I deliberately avoided “hackathon dashboard syndrome.”

The product uses:

• a sticky control sidebar
• a dense topbar with mission context
• operational cards instead of generic marketing tiles
• event logs and policy chips
• premium dark styling with muted contrast

The goal was to make the interface feel like Linear meets Brex meets an AI operations console.

Important Engineering Decisions

1. Native OWS instead of CLI orchestration

I chose the Node SDK because it keeps the wallet system in-process and easier to reason about.

2. Provider adapters stay isolated

Every external integration lives under src/lib/adapters/, which makes it easy to evolve or swap providers later.

3. Explicit provider failure over fake success

I removed silent mock behavior from the main provider paths. If a provider is missing credentials or fails, the UI shows the integration error instead of pretending the call worked.

4. Dynamic pages for live integrations

Pages that depend on live providers are marked dynamic so they don’t try to execute network requests during static generation.

What I’d Build Next

• Replace seeded mission state with database-backed runtime state
• Add a true x402 buyer flow instead of a simulated payment event
• Add downloadable reports
• Add mission history and replay
• Add richer chain-specific signing workflows
• Add multi-user operator approvals

Agent Swarm CFO is not “agents calling APIs.” It is a finance-grade control surface for autonomous execution.

That distinction matters. As soon as agents are allowed to spend, sign, or transact, governance becomes the product. OWS makes that governance legible, enforceable, and auditable.

Screenshots

Github Repo: https://github.com/harishkotra/agent-swarm-cfo