System Architecture
Below is a blueprint of Degents as an Agent OS for DeFi. The design unifies coordination logic, crypto settlement, and policy controls into a single runtime that scales from a solo agent on a Raspberry Pi to thousands of co-located actors on a cloud cluster.
3.1 Layered Stack Overview
Agents live in Layer 1, invoke actions in Layer 3, which sign and settle via Layer 2, while persisting knowledge in Layer 4. Layer 5 exposes everything to humans, services, or other agent colonies.
3.2 Agent Coordination Core (Layer 1)
Scheduler
Time-slice and priority-queue millions of concurrent agent tasks.
Message Bus
Pub-sub + RPC hybrids for low-latency agent-to-agent and agent-to-service communication.
Memory Kernel
Short-term scratchpad plus hooks to Layer 4 for long-term vector / relational storage.
Policy Engine
Deterministic checks (KYC, spend caps, rate limits) executed before each signed action.
Simulation Sandbox
Dry-run environment for strategy testing with forked chain state.
Agents can be written as pure-function “skills”, state-full class instances, or LLM loops. They communicate through Intent messages (structured JSON) and can form temporary “coalitions” for complex workflows (e.g., arbitrage + hedging + compliance review).
3.3 Universal Wallet & Transaction Layer (Layer 2)
Goal: make every chain and venue feel like one ledger.
AccountProvider
Pluggable modules for custodial (MPC, smart wallets) or self-custody key stores.
ChainAdapter
Normalises RPC, EIP-712, GAS, and fee sponsorship across EVM, Solana, Cosmos, etc.
Bridge Router
Intent-based cross-chain transfers with automatic pathfinding and risk checks.
Venue Gateway
Signed REST/WebSocket wrappers for CEX APIs (Binance, Coinbase, OKX).
Tx Builder
Deterministic transaction assembly from high-level intents (swap, supply, unwrap).
All transaction objects implement .simulate(), .sign(), .submit(), returning a canonical receipt that feeds back into the Coordination Core.
3.4 Action Fabric (Layer 3)
The “function marketplace” for the Agent OS.
Schema-first: Each action is defined by a JSON (or Python-typed) schema ➜ auto-generates client stubs, validation, and UI docs.
Dual invocation path:
JSON mode — for LLMs / remote agents.
Python native — import and call like a regular function for zero-latency intra-process use.
Registry & Reputation: Signed metadata, versioning, stake-weighted ratings; bad actors are slashed.
Hot-swap deployment: Actions can be upgraded with deterministic rollback and replay tests to guarantee safety.
3.5 State & Storage (Layer 4)
High-speed KV (Redis / Memory)
Ephemeral coordination state & rate counters.
Relational (Postgres, SQLite)
Deterministic journal of intents, receipts, and policy decisions.
Vector DB (Qdrant, Weaviate)
Long-term semantic memory for LLM agents.
Off-chain Blob / IPFS
Large artefacts, model binaries, audit archives.
Secrets Vault
Encrypted API keys, MPC shares, policy secrets.
All tiers expose a uniform ACID-compliant transaction API so workflows remain replayable.
3.6 Interface & Orchestration (Layer 5)
CLI & SDKs: Create, test, and deploy agents with one command
(degent init arb-bot).REST/gRPC Gateway: Polyglot services can trigger agents or subscribe to receipts.
Web Dashboard (Tauri/React): Visualises coalitions, wallet balances, pending intents, and policy health.
Edge Deployment: WASM-compiled agent runtimes for CDN / IoT execution.
3.7 Security, Trust & Compliance (Cross-cutting)
Policy Checks
Deterministic pre-flight rules; if any fail, the intent is rejected before signing.
Staking & Slashing
Action publishers must stake; malicious or faulty actions lose stake via on-chain arbitration.
Formal Verification Hooks
Optionally require agents to attach zero-knowledge proofs or SMT-checked attestations for critical contracts.
Audit Layer
Merkle-compressed logs of every message, decision, and signature—anchored periodically to L1 for immutability.
Dynamic Spend Limits
Hierarchical budget envelopes refresh hourly/daily to mitigate key-compromise blast radius.
3.8 Putting It All Together — Dual Trigger Flows
Below is a unified flow that shows how Degents agents coordinate and execute either an automated market signal or a direct human instruction. The same pipeline, policy checks, and wallet layer apply in both cases.
1 Trigger
A monitoring agent by detects a price gap or on-chain event.
A user issues a JSON/Python command: {"task":"rebalance","target_allocation":{"BTC":0.3,"ETH":0.7}}.
2 Intent Drafting
Strategy coalition proposes an Intent: dex.swap(USDC→ETH, 50 k) to capture the arbitrage.
Coordinator agent parses the human request and drafts an Intent: portfolio.rebalance(target_allocation…).
3 Policy & Simulation
Policy Engine sim-runs the swap, checks KYC, budget envelope, and VaR limits.
Same deterministic checks (KYC, budget, policy) run against the rebalance plan.
4 Sign & Submit
Tx Builder signs the bundle; ChainAdapter routes it to the optimal DEX/chain.
Rebalance may produce multiple txs (swaps, liquidity pulls); each is signed and routed.
5 Receipt & State Update
On-chain receipts are persisted; Memory Kernel updates PnL and may dissolve the coalition.
Receipts update portfolio state; user dashboard reflects new balances and risk metrics.
6 Continuous Loop
Monitoring agent returns to watch for the next signal.
User may issue follow-up commands, or automation agents continue periodic rebalancing.
Whether initiated by an algorithmic trigger or a human voice/chat request, the Agent OS for DeFi guarantees:
Unified coordination through the same Message Bus and Scheduler.
Deterministic guard-rails via the Policy Engine before any private key is used.
Transparent auditability—every intent, decision, and signature is logged, Merkle-hashed, and anchor-committed on-chain.
This dual-trigger design is fundamental to realizing Autonomous Decentralized Finance that is both machine-driven and human-steerable.
Last updated