FarmDash Agent Hub Complete Manual: Every Skill, SDK, and MCP Tool Explained

The Agent Hub is the only part of FarmDash that has direct lines to your wallet, your trading capital, and your autonomous loops. That makes it the most powerful surface we ship — and the most dangerous one to use blindly. This manual exists so you never have to guess.

If you have read the Signal Architect Complete Reference you already know the spot-execution layer. This guide zooms out: it covers all five skills, every distribution channel, and the precise composition pattern that lets one agent research a protocol on Trail Intelligence, ground itself on Wagon Steward, and execute through Signal Architect — without ever leaving the zero-custody contract.

What is the FarmDash Agent Hub?

The FarmDash Agent Hub is a unified set of tools that let an autonomous AI agent research, plan, execute, and monitor DeFi farming positions without ever holding the user's private keys. It ships through three independent distribution channels so that whatever framework your agent runs on, there is a native integration:

1. Five OpenClaw skills on the ClawHub marketplace — each is a separately versioned, ClawScan-reviewed contract with its own permission boundary.
2. The @farmdash/mcp-server Model Context Protocol server — drop-in for Claude Desktop, Cursor, Cline, and any MCP-compatible client. Exposes 31 tools.
3. The @farmdash/agent-kit TypeScript SDK + REST API — for custom agents built on Eliza, LangChain, OpenAI Agents SDK, Anthropic Agent SDK, or hand-rolled stacks.

The five skills, taken together, cover the four phases of an autonomous DeFi loop:

• Sense — Trail Intelligence (research) + Wagon Steward (current portfolio state)
• Decide — Trail Marshal (orchestration cookbook) + Futures Strategist analysis tools
• Present — every skill returns structured JSON the agent can show the user
• Verify — Signal Architect (spot legs) and Futures Strategist (perps legs) execute only after the user signs locally

You almost never install just one skill in a real deployment. The composition section below shows why.

Which OpenClaw skill should I install first?

Install the skill that matches the most cautious capability you need. Read-only first, execution second. Here is the canonical decision table.

A research-only agent installs Trail Intelligence + Wagon Steward and stops there — those two combined cover ~80% of "what should I farm?" questions and they cannot move funds, period.

A full execution agent installs all five. Trail Marshal is intentionally lightweight (1 tool) because it does not bundle, invoke, or import other skills — it documents the composition pattern in a structured catalog so the LLM picks a recipe; the agent then calls each sub-skill directly under that sub-skill's own ClawScan-reviewed contract.

What does each skill actually do?

This section is the per-skill brief. Every skill has its own SKILL.md with the full tool reference; this is the operator-level summary.

Trail Intelligence v2.1.0 — Read-only DeFi research

Trail Intelligence is the research layer. It exposes 12 read-only tools covering the entire surface of public protocol data plus FarmDash's proprietary Trail Heat™ ranking, Pioneer Pace™ scoring, and sybil-resistance heuristics. Three new tools shipped in v2.1: get_protocol_metadata (governance + audit data), get_protocol_risk_factors (decomposed Trail Heat with the actual contributing signals), and find_capital_route (capital-efficient hop suggestions across chains).

Use Trail Intelligence whenever the agent needs to answer what before answering how. It cannot move funds, sign, approve, or queue any transaction. Rate limits are Scout 5 req/24h, Pioneer 500 req/day, Syndicate 50,000 req/day.

Wagon Steward v0.5.1 BETA — Read-only portfolio aggregation

Wagon Steward is the grounding layer. Six read-only tools answer the agent's "where am I right now?" questions: get_portfolio_summary (totals + top-3 positions, USD-rounded), get_position_health (per-position health flags), get_idle_capital (uninvested USD by chain), get_capital_efficiency (yield-per-dollar across positions), get_rebalance_plan (research output, not an executable transaction), and the Syndicate-tier watch_wagon for proactive webhook alerts.

Every endpoint is a GET. Even the rebalance plan is research — it returns a JSON spec the agent must hand to Signal Architect for the user to review and sign. Wagon Steward never holds keys, never queues transactions, and never returns calldata.

Trail Marshal v0.1.1 BETA — Read-only orchestration cookbook

Trail Marshal is the decision layer's reference manual. It exposes a single tool — list_workflows — that returns a static JSON catalog of ten named multi-skill workflow recipes. Examples:

• research_only — Trail Intelligence walk-through, no execution
• airdrop_rotation — find the highest Trail Heat protocol, scout its Sybil risk, plan a rotation
• farm_hyperliquid — points-mode execution loop with HLP and order-book activity
• farm_solana_restaking — Kamino → Drift → Jupiter rotation
• delta_neutral_setup — long spot via Signal Architect, short perp via Futures Strategist
• funding_capture — funding-rate arbitrage cookbook
• protect_portfolio — drawdown shielding workflow
• idle_capital_deploy — sweep idle USD into the highest-Trail-Heat passive yield
• migrate_chain — relocate liquidity between L2s
• bounded_autopilot — Syndicate-tier supervised autonomous loop

Trail Marshal does not invoke any other skill. It documents the recipe; the agent then calls each step against the appropriate read-only or signing skill under that skill's own contract.

Signal Architect v3.3.0 — Spot execution + autopilot

Signal Architect is the spot execution layer. It exposes 31 tools covering the full agent lifecycle: discovery, sizing, execution, monitoring, adaptation, and automation. Swap routing aggregates 0x (single-chain EVM), Li.Fi (cross-chain, 60+ networks), and Alchemy x402 (Base-to-Base optimized). Trail Heat data, sybil auditing, portfolio optimization, historical analytics, events, webhooks, and the Autonomous Operator session manager are all here.

Critically: Signal Architect signs nothing on its own. Every state-changing call returns standard EVM calldata your agent's wallet client signs locally with EIP-191 (personal_sign). Replay protection is a 60-second nonce window. The fee model is volume-based — 75 bps default, 35 bps at $10K+, 25 bps at $100K+.

Futures Strategist v2.2.0 — Hyperliquid perps execution

Futures Strategist is the perps execution layer. It exposes 8 tools dedicated to Hyperliquid perpetual futures: funding-rate scan, regime detection (trend / chop / squeeze), strategy analysis with pre-trade simulation, and EIP-712-signed order execution via the user's Hyperliquid API wallet. The strategy families in v2.2 cover funding arbitrage, momentum (long and short), trend-pullback, mean-reversion, breakout-continuation, vol-compression breakout, and delta-neutral pair construction. The no_trade family is a first-class output — the strategist will refuse to size a position when regime quality is below threshold.

Every order leaves the user's wallet via EIP-712 only. FarmDash never holds the Hyperliquid API key.

How do the skills compose into one workflow?

The composition pattern is Sense → Decide → Present → Verify. Every multi-skill workflow respects this order, and Trail Marshal's catalog encodes it in every recipe. Here is the canonical execution loop:

1. Sense — Trail Intelligence.get_top_opportunities() returns ranked protocols by Trail Heat. Wagon Steward.get_portfolio_summary() grounds the agent in the user's actual position. The agent now knows the territory and the wagon's current load.
2. Decide — The agent picks a Trail Marshal recipe matching the user's intent ("airdrop rotation", "delta neutral setup", "funding capture"). Trail Marshal returns the recipe steps; the agent does not execute the recipe — it interprets it.
3. Present — The agent surfaces a plain-language summary to the user: "I found Hyperliquid at Trail Heat 87 with confirmed airdrop status. You have $4,200 idle USDC on Base. The recipe says bridge to Hyperliquid via Li.Fi, deposit into HLP, then size a maker-side perp position. Approve?"
4. Verify — Only after explicit user approval does the agent call Signal Architect.get_swap_quote() and then Signal Architect.execute_swap() with the user-signed payload. For the perp leg, it calls Futures Strategist.analyze_strategy() for pre-trade simulation, then Futures Strategist.execute_order() with the EIP-712 signature.

The pattern is recursive — every state-changing leg gets its own user signature, never a blanket approval. This is how an agent can run "autonomously" while still operating fully within the user's consent boundary.

How do I authenticate as an agent?

There are two authentication modes — read-only access and state-changing access — and they are intentionally separated.

For read-only calls (Trail Intelligence, Wagon Steward, Trail Marshal, all GET endpoints in Signal Architect and Futures Strategist) the auth is an optional bearer token in the Authorization: Bearer <FARMDASH_API_KEY> header. No key required for the Scout tier (5 requests / 24 hours). A Pioneer key unlocks 500 req/day; a Syndicate key unlocks 50,000 req/day plus webhook delivery.

For state-changing calls (/api/agents/swap, /api/agents/perps/order, autopilot session creation) the auth is a cryptographic signature, not an API key:

The advantage is that no API key controls funds. A leaked Pioneer bearer token gets you higher rate limits — that's it. To move funds an attacker would need the user's private key, which FarmDash never sees. Detailed payload formats live in the Signal Architect Complete Reference and the Eliza Agent Swap Integration guide.

Which AI clients does FarmDash natively support?

The Agent Hub ships first-class integrations for every major agent runtime. Pick by what your stack already uses:

The MCP server is the lowest-friction path for Claude Desktop and Cursor users — one npx command and the agent has all 31 tools immediately. The OpenClaw skills are the lowest-friction path for ClawHub users — install the five separately, each with its own permission boundary. The Agent-Kit SDK is the lowest-friction path for TypeScript developers building custom agents.

What does a real workflow look like end-to-end?

Below are four reference workflows lifted directly from the Trail Marshal catalog, with the actual skill calls annotated. These are not pseudocode — they are the live API surface.

Airdrop rotation (research → present, no execution)

1. Trail Intelligence.get_top_opportunities({ limit: 10, minTrailHeat: 70 })
   → returns ranked confirmed/points-active protocols
2. Trail Intelligence.get_protocol_risk_factors({ slug: <top.slug> })
   → returns the decomposed Trail Heat (TVL/Status/Category/Momentum/Recency)
3. Wagon Steward.get_portfolio_summary()
   → returns the user's current top-3 positions + idle capital
4. Trail Intelligence.find_capital_route({ from: <user_chain>, to: <protocol_chain> })
   → returns capital-efficient bridge hops
5. Present plan to user. No signing. No execution. STOP.

Delta-neutral setup (full execution loop)

1. Trail Intelligence.simulate_points({ protocol: 'hyperliquid', usd: 5000 })
   → returns expected points + dollar value
2. Wagon Steward.get_idle_capital()
   → confirms the user has $5,000 idle USDC on a supported chain
3. Trail Marshal.list_workflows({ filter: 'delta_neutral_setup' })
   → returns the recipe spec
4. Futures Strategist.analyze_strategy({
     family: 'delta_neutral_pair', asset: 'HYPE-PERP', notional: 5000
   })
   → returns expected funding capture, regime score, sizing, no-trade flag if regime is bad
5. Present full plan to user. User approves.
6. Signal Architect.execute_swap({ ... })  → user signs EIP-191 → spot leg fills
7. Futures Strategist.execute_order({ ... }) → user signs EIP-712 → perp leg fills
8. Wagon Steward.get_position_health() → confirms both legs settled

Funding capture (recurring loop)

1. Futures Strategist.scan_funding_rates({ minAbsRate: 0.01 })
   → returns markets paying funding above threshold
2. Trail Intelligence.get_protocol_metadata({ slug: 'hyperliquid' })
   → confirms protocol health
3. Wagon Steward.get_portfolio_summary()
   → confirms the user has margin headroom
4. Futures Strategist.analyze_strategy({
     family: 'funding_arb', asset: <market>, holdHours: 24
   })
5. Present + user signs EIP-712 → Futures Strategist executes
6. Schedule re-evaluation after holdHours via Signal Architect.create_session() (Syndicate tier)

Idle capital deploy (Wagon Steward driven)

1. Wagon Steward.get_idle_capital()
   → returns idle USD by chain
2. Trail Intelligence.get_top_opportunities({
     filterChain: <user.chain>, category: 'restaking|lending|stable_yield'
   })
3. Trail Marshal.list_workflows({ filter: 'idle_capital_deploy' })
4. Wagon Steward.get_capital_efficiency()
   → confirms the deploy improves portfolio yield-per-dollar
5. Present + user approves
6. Signal Architect.execute_swap() → user signs → idle capital lands in the new position

Every workflow ends in either a STOP (research) or an explicit per-leg user signature (execution). There is no "agent has standing approval" mode in any skill.

How is the Agent Hub priced?

The same three tiers apply across all five OpenClaw skills, the MCP server, the Agent-Kit SDK, and the REST API. One bearer token unlocks all of them at the corresponding tier.

Settlement is in USDC on six EVM networks: Ethereum, Base, Arbitrum, Linea, Optimism, and Polygon. The on-chain verify-payment Edge Function checks the receiving treasury for the literal $29 or $199 USDC transfer — no Stripe, no fiat gateways, no third-party billing intermediaries.

What are the zero-custody guarantees?

This is the contract. Every skill in the Agent Hub upholds it identically.

1. No private keys ever touch FarmDash infrastructure. Read-only skills (Trail Intelligence, Wagon Steward, Trail Marshal) literally have no signing tools — they cannot construct or send a transaction. Execution skills (Signal Architect, Futures Strategist) return calldata or typed-data payloads that your agent's wallet client signs locally.
2. No "agent has standing approval" mode. Every state-changing leg requires an explicit fresh signature. Autopilot sessions (Syndicate tier) bound the agent's authority with a validUntil timestamp and an explicit max-USD ceiling per call.
3. Replay protection on every signed call. Spot swaps use a 60-second nonce window. Perps use Hyperliquid's native nonce. Sessions use a session-bound timestamp.
4. No leaked-key escalation path. A leaked bearer token unlocks rate limits, not funds. To move money, an attacker would need the user's private key — which FarmDash never sees.
5. Public on-chain treasury. The receiving treasury wallet for subscription settlement is a single, public address (referenced in the dashboard's PaymentService). Every payment is auditable on a block explorer.
6. Open source signing layers. The EIP-191 payload format and the @farmdash/agent-kit SDK are both open and inspectable, so any user can verify the signing path matches the documented spec.

How do I install the Agent Hub right now?

Three install paths, ranked by friction:

Path A — Claude Desktop / Cursor / Cline (lowest friction):

# Add to your MCP config (~/.config/claude_desktop_config.json or equivalent):
{
  "mcpServers": {
    "farmdash": {
      "command": "npx",
      "args": ["-y", "@farmdash/mcp-server"]
    }
  }
}

Restart your client. All 31 tools appear immediately. Scout tier works without any API key.

Path B — OpenClaw on ClawHub (per-skill install):

Install each of the five skills from the ClawHub marketplace, or grab the raw SKILL.md files directly:

https://www.farmdash.one/openclaw-skills/farmdash-trail-intelligence/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-wagon-steward/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-trail-marshal/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-signal-architect/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-futures-strategist/SKILL.md

Drop them into your agent's skills folder. Each is independently versioned and ClawScan-reviewed.

Path C — Custom TypeScript agent (Eliza, LangChain, or hand-rolled):

npm install @farmdash/agent-kit

import { FarmDashClient } from '@farmdash/agent-kit';

const client = new FarmDashClient({ apiKey: process.env.FARMDASH_API_KEY });

// Sense
const opportunities = await client.getTopOpportunities({ limit: 5 });

// Ground
const portfolio = await client.getPortfolioSummary({ wallet: '0x...' });

// Quote (no signing yet)
const quote = await client.getQuote({
  fromChainId: 8453, toChainId: 8453,
  fromToken: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
  toToken: '0x4ed4e862860bef6f5bc2b489d12a64703a110a12',
  fromAmount: '5000000000', // $5,000 USDC (6 decimals)
});

// Execute (your wallet client signs the calldata in quote.txData locally)

For the full Eliza + EIP-191 walkthrough, see the Eliza Agent Swap Integration guide.

What's coming next?

Three deepenings are scoped on the Agent Hub roadmap, all additive — no existing tools will be removed:

1. Trail Marshal v1.0 — graduates from a static catalog to an active orchestrator with bounded autopilot loops (Syndicate tier).
2. Wagon Steward v1.0 — adds historical position tracking, P&L attribution, and a simulate_rebalance tool that returns expected slippage + gas before the user ever signs.
3. Camp Guard, Ledger Keeper, Supply Master, Hedge Warden — four additional skills currently scoped in docs/OPENCLAW-DEEPENING-PLAN.md for risk monitoring, accounting, capital sourcing, and hedging. Tracked but not yet shipped.

Signal Architect's surface is intentionally frozen at v3.3.0 — additions go to the specialized skills, not the monolith.

Hitch Your Oxen — Stop Guessing

Stop building agents that ask you for your seed phrase. Paste your 0x address into FarmDash Watch Mode to decrypt your wagon's risk profile in seconds, then pick your install path and let your agent read, plan, and verify across all five skills under a single zero-custody contract.

Related Guides

• Signal Architect Complete Reference — every one of the 31 spot tools, in detail
• Eliza Agent Swap Integration — full EIP-191 walkthrough for the Eliza framework
• Signal Architect Loop — the publishing pipeline for agentic content
• Trail Heat™ Methodology — how the ranking score is computed
• Sybil Resistance 2026 — the heuristics behind the sybil-audit tools