Architecture

YieldSeeker separates deciding what to do from doing it. An agent can reason about your goals and propose an allocation, but nothing it decides can move funds outside the platform’s execution controls.

Four layers

• Agent Intelligence — understands your preferences, remembers rules from past conversations, and explains its decisions. It does not execute transactions.
• Allocation Engine (Autoseek) — evaluates opportunities and decides how to allocate funds within the current agent type’s strategy.
• Monitoring — continuously checks your positions against the limits in your rules and wakes the Allocation Engine when one is breached. It cannot decide or execute.
• Execution Framework — validates and executes only permitted onchain actions through the Agent Wallet, Adapter Registry, and adapters.

Each layer works inside the one around it. Agent Intelligence can turn a preference into a rule, but the Allocation Engine only turns a rule into a target allocation if it passes eligibility, liquidity, and portfolio checks. Monitoring keeps watching the resulting positions against those rules; a breach hands the decision back to the engine instead of acting on its own. The Execution Framework then only executes an allocation if it maps to an approved adapter and target. There is no path through this chain for a request like “send my funds to this address” — Agent Intelligence has no execution capability, and the Execution Framework only recognizes registered adapters and targets.

flowchart LR
  User[You] --> Intelligence[Agent Intelligence]
  Intelligence --> Engine[Allocation Engine]
  Engine --> Execution[Execution Framework]
  Execution --> Protocols[Supported DeFi protocols]
  Monitoring[Monitoring] -. breach wakes .-> Engine

How a preference becomes an action

flowchart LR
  Conversation[Conversation] --> Memories[Memories]
  Memories --> Rules[Rules]
  Rules --> Engine[Allocation Engine]
  Rules --> Monitoring[Monitoring]
  Monitoring -. breach wakes .-> Engine

A conversation can produce a memory. A memory is compiled into one or more rules. Rules are one input the Allocation Engine applies alongside eligibility, liquidity, and portfolio constraints — a rule can narrow or bias an allocation, but it cannot make an unsupported or unsafe target eligible, and it never bypasses the Execution Framework. The same rules tell monitoring what to watch, so changing a preference changes both what the engine allows and which limits are watched. See How agents work.

Principles

• Simplicity through automation — DeFi can demand constant attention to markets, protocols, liquidity, and incentives. Agents take on that routine work without asking you to approve every transaction, while keeping important decisions and limits visible.
• Verify, don’t trust — where practical, YieldSeeker checks protocol and portfolio information against onchain state instead of relying only on third-party dashboards or reported metrics.
• Constrained execution — every action goes through approved adapters and registered targets, never unrestricted contract calls.
• You stay in control — your connected wallet owns each Agent Wallet and can withdraw its base asset and ETH directly. Exiting a vault position goes through a supported adapter and depends on protocol liquidity.
• One model for every agent type — a new agent type brings a new goal and strategy, but the same wallet, execution, and monitoring model.

These are design goals, not guarantees of profit, safety, liquidity, or uninterrupted service. Read Risks and limitations before using an agent.

Where to go next

• How agents work for the account and agent lifecycle.
• Vault Agent for what the Allocation Engine checks on an ongoing basis.
• Security for how the Execution Framework constrains a compromised or malicious operator.
• Platform architecture for the contract-level and API-level view of these same layers.