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 ten skills, every distribution channel, and the precise composition pattern that lets one agent research a protocol, ground itself on wallet state, guard the transaction path, execute through the owning skill, and reconcile the result - 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. Ten 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 60 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 ten skills, taken together, cover the phases of an autonomous DeFi loop:

• Sense — Trail Intelligence (research) + Wagon Steward (current portfolio state)
• Decide — Trail Marshal (workflow planning), Supply Master (yield ranking), Hedge Warden (hedge plan), and Futures Strategist analysis tools
• Guard — Camp Guard (approval, transaction, route, and health checks)
• Present — every skill returns structured JSON the agent can show the user
• Verify — Signal Architect (spot legs), Futures Strategist (perps legs), Ledger Keeper (records), and Autonomous Operator (session context)

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 the research, portfolio, guard, execution, ledger, and session skills. Trail Marshal does not bypass other skills; it builds a plan and records workflow state so the agent can call each owning skill under that 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.2.0 - Read-only DeFi research

Trail Intelligence is the research layer. It exposes read-only tools covering public protocol data plus FarmDash's proprietary Trail Heat ranking, Pioneer Pace scoring, and sybil-resistance heuristics. Core tools include get_trail_heat, get_protocol_metadata, get_protocol_risk_factors, find_capital_route, get_agent_events, audit_sybil_risk, and get_historical_trailheat.

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.6.0 BETA - Read-only portfolio aggregation

Wagon Steward is the grounding layer. Read-only tools answer the agent's "where am I right now?" questions: get_wallet_balances, get_portfolio_summary, get_position_health, get_idle_capital, and get_token_prices.

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 v1.0.0 - Guarded workflow orchestration

Trail Marshal is the decision layer's orchestration desk. It exposes list_workflows, plan_workflow, run_workflow, and get_workflow_status. The catalog now includes fourteen named recipes, and the orchestrator classifies missing skills, state-changing steps, confirmation counts, and safe fallbacks before an agent claims a workflow is executable. 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 execute any state-changing step. It documents and records the workflow; the agent then calls each step against the appropriate read-only, guard, or signing skill under that skill's own contract.

Signal Architect v3.4.0 - Spot execution + typed intents

Signal Architect is the spot execution layer. It exposes quote, swap, confirmation, portfolio optimization, typed intent, and risk-sentinel tools. Swap routing aggregates 0x (single-chain EVM), Li.Fi (cross-chain, 60+ networks), and Alchemy x402 (Base-to-Base optimized). Typed intents can produce real calldata for supported adapters such as ERC4626 deposit and withdraw, while refusing placeholders.

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+.

🌐 Solana Mainnet Support

FarmDash now supports native Solana Mainnet swapping. Because Solana public keys are case-sensitive Base58 strings, the SDK maintains absolute casing preservation via the safeLower normalization helper.

Parameter Formatting for Solana:

• fromChainId / toChainId: Set to "solana-mainnet".
• agentAddress / toAddress: Must be a valid Base58 Solana address (32-44 characters).
• signature: Must be a Base58-encoded Ed25519 signature (87-88 characters).
• nonce: Collision-resistant nonce string containing a millisecond timestamp followed by a hex or random suffix (e.g., 1772345678901-abc).

// Example: Solana detached signing using TweetNaCl & bs58 in Node/SDK environment
import nacl from 'tweetnacl';
import bs58 from 'bs58';
import { FarmDashClient } from '@farmdash/agent-kit';

const client = new FarmDashClient({ apiKey: 'fd_live_...' });
const nonce = `${Date.now()}-abc`;

const swapParams = {
  fromChainId: 'solana-mainnet',
  toChainId: 'solana-mainnet',
  fromToken: 'So11111111111111111111111111111111111111112', // Native SOL mint
  toToken: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',  // USDC mint
  fromAmount: '1000000000', // 1 SOL (9 decimals)
  agentAddress: '5R1Xn9x8hD6uP6T8gY4K1a5v8hD6uP6T8gY4K1a5v8hD',
  toAddress: '5R1Xn9x8hD6uP6T8gY4K1a5v8hD6uP6T8gY4K1a5v8hD',
  nonce
};

// 1. Build deterministic payload string
const payload = FarmDashClient.buildSignaturePayload(swapParams, nonce);

// 2. Sign using Ed25519 Detached Signature
const msgBytes = new TextEncoder().encode(payload);
const sigBytes = nacl.sign.detached(msgBytes, walletKeyPair.secretKey);
const signature = bs58.encode(sigBytes);

// 3. Submit for execution
const result = await client.executeSwap(swapParams, signature, nonce);
console.log('Swap executed successfully:', result.data.txHash);

Futures Strategist v2.3.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.

Camp Guard v1.0.0 - Pre-execution risk gate

Camp Guard audits allowance exposure, transaction policy, and route risk before signing. Use audit_allowance_risk, simulate_transaction_risk, and run_risk_sentinel before swaps, deposits, emergency exits, and hedge execution.

Supply Master v1.0.0 - Yield selection

Supply Master calls live DeFi yield data and ranks pools by sustainability instead of raw APY alone. Use compare_yields for stablecoin ladders, idle capital deployment, and delta-neutral spot legs.

Hedge Warden v1.0.0 - Delta hedge planning

Hedge Warden converts spot farming exposure into hedge targets with recommend_delta_hedge. It produces a handoff only; Futures Strategist must still perform fresh research, sizing, and confirmation before any order.

Ledger Keeper v1.0.0 - Post-trade records

Ledger Keeper summarizes recorded activity with ledger_realized_pnl and exports spot execution records with ledger_tax_export. It is informational only and not tax, legal, or accounting advice.

Autonomous Operator v1.0.0 - Session context

Autonomous Operator keeps persistent sessions coherent with create_session, session_heartbeat, get_farming_context, patch_farming_context, get_event_stream_snapshot, verify_delegation, configure_autopilot, and autopilot_cycle.

How do the skills compose into one workflow?

The composition pattern is Sense -> Decide -> Guard -> 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 and calls plan_workflow to classify missing skills, state-changing steps, and confirmation count.
3. Guard — Camp Guard checks approvals, route edge, transaction policy, and health/liquidation inputs before signing.
4. 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?"
5. Verify — Only after explicit user approval does the agent call get_swap_quote, simulate_swap_execution, and then execute_swap with the user-signed payload. For the perp leg, it calls analyze_futures_strategy for pre-trade simulation, then execute_perp_order with the EIP-712 signature. Ledger Keeper and Autonomous Operator reconcile the result.

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 60 tools immediately. The OpenClaw skills are the lowest-friction path for ClawHub users — install the ten 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.simulate_swap_execution({ intentId, walletAddress }) → route passes preflight
7. Signal Architect.execute_swap({ ...simulationId })  → user signs EIP-191 → spot leg fills
8. Futures Strategist.execute_order({ ... }) → user signs EIP-712 → perp leg fills
9. 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.simulate_swap_execution() → route passes preflight
7. 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 ten 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 $39.99 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 60 tools appear immediately. Scout tier works without any API key.

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

Install each skill 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
https://www.farmdash.one/openclaw-skills/farmdash-camp-guard/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-supply-master/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-hedge-warden/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-ledger-keeper/SKILL.md
https://www.farmdash.one/openclaw-skills/farmdash-autonomous-operator/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?

The latest deepening pass shipped the previously scoped specialist skills. Remaining roadmap items are additive — no existing tools will be removed:

1. Trail Marshal v1.x — expands guarded orchestration persistence beyond in-runtime run records.
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. Supply Master v1.x and Hedge Warden v1.x — add richer venue-specific filters and deeper hedge invalidation telemetry.

Signal Architect remains focused on execution. Additions that are primarily risk, records, yield selection, hedging, or state coordination live in the specialized skills.

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, guard, execute, and verify across all ten skills under a single zero-custody contract.

Related Guides

• Signal Architect Complete Reference — the spot execution 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