Dahood Agent

Doing one simple thing in DeFi on Robinhood Chain takes too many manual steps. To swap ETH for USDG you need to know both contract addresses, pick the right pool fee tier out of four, work out a minimum acceptable output, approve Permit2, approve the Universal Router, and only then send the transaction.

Every one of those steps is somewhere to get lost. The expensive mistakes are not the hard steps — they are the ones that look easy. Picking the wrong fee tier quietly costs you price with no error message, and typing USDC on a chain that has no USDC fails with no explanation at all.

Dahood is an intent layer, not an AI wrapper around a swap widget. The difference is where the boundary sits: a language model may only fill a data structure called Intent. It never produces calldata, a contract address, or an output figure. Turning an Intent into a transaction is deterministic code you can read and test.

The consequences are concrete. The model cannot invent a token address, because any hex-shaped string is dropped before it reaches the resolver. It cannot invent an expected output, because that number comes from the Uniswap Quoter. And it cannot hide a warning, because the warnings field does not exist in the schema it is allowed to fill.

Most sentences never reach a model at all. A rule-based parser handles clear commands offline and instantly; the model is only called when the parser’s confidence falls below 0.8. If it is still unsure after that, the agent asks a question rather than guessing.

Every command goes through the same seven stages, in order. Any stage may stop the run, and its reason always reaches the screen.

  sentence
     │
     ▼
  ┌────────┐   rules first; the model only under 0.8 confidence
  │ parse  │   output: Intent (no addresses, no calldata)
  └───┬────┘
      ▼
  ┌────────┐   local registry → Blockscout → fail
  │resolve │   this is where warnings are born
  └───┬────┘
      ▼
  ┌────────┐   all four tiers asked: 0.01 / 0.05 / 0.3 / 1%
  │ quote  │   best output wins; the winning tier is shown
  └───┬────┘
      ▼
  ┌────────┐   daily limit, price impact, oracle deviation
  │ guard  │
  └───┬────┘
      ▼
  ┌────────┐   honeypot, sell tax, liquidity, LP lock, age
  │ screen │   required off-registry, in every autonomy mode
  └───┬────┘
      ▼
  ┌────────┐   eight fixed fields, always populated
  │preview │   Confirm dies if output is empty or a check blocks
  └───┬────┘
      ▼
  ┌────────┐   approve → approve → swap, one at a time
  │execute │   green only after a successful receipt
  └────────┘

Stages resolve through screen run in every autonomy mode. Auto mode removes the manual confirmation step and not one validation step.

Fee tiers are never hardcoded. All four are asked on every quote, the best output wins, and the winning tier is printed on the preview card so you can check it.

What is guaranteed:

• No transaction runs without being shown first — route, expected output, fee tier, slippage, and what it leaves of today’s limit.
• Confirm is disabled when the expected output cannot be computed or a block warning fired, and the reason is printed directly beneath the button.
• Tokens outside the registry always pass the screener and always need a human — even in Full AI mode.
• The private key is never sent to a server. Everything is signed in your browser.

What is not:

• The key lives in this browser. There is no server copy and no recovery path. Clearing browser data without an export loses the funds permanently.
• The daily limit is per device. It is kept in localStorage, not in a contract. It protects you from an agent running away in this browser — not from someone who already holds your key.
• There is no MEV protection. There is a 0.5% slippage cap by default, which bounds how bad a fill you accept — it does not stop anyone getting in front of your transaction.
• The screener reads third-party sources. Any check that cannot be completed is recorded as “could not be determined” and is never counted as safe.
• Uniswap, Morpho, Spark and Lighter are not ours and are not audited by us.

$DAHOOD unlocks agents. It is not a fee token — nothing is skimmed from your trades.

• Always free: Swap, Yield and Vault. No holding required.
• Gated: Stock Token and Perps, unlocked when the wallet holds 100,000 $DAHOOD. Once the token exists, progress is shown as a running figure rather than a bare padlock.
• Until $DAHOOD is deployed, those agents read unlocks when $DAHOOD launches and show no progress figure. A gate no balance can satisfy must not be presented as one the reader is falling short of.
• The threshold is read from deployment configuration, so it can change without a code change.

Distribution and emissions are not settled. This page will be updated when they are — we would rather leave it blank than publish a number nobody has decided.

Phases 1 through 8 are live: the intent layer, registry and resolver, quoting and preview, wallet and execution, vault and autonomy, the yield/stock/perps/DCA agents, the screener, and portfolio plus PWA.

What is in progress and what is planned lives on the roadmap, marked by phase rather than by date.