Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.dzap.io/llms.txt

Use this file to discover all available pages before exploring further.

DZap AI is structured so that reasoning stays flexible while execution stays disciplined. Five layers, clear contracts between them.

​
The five layers

┌──────────────────────────────────────────────┐
│         Interface Layer                      │
│   MCP server · CLI · App · Plugins · IDEs    │
└─────────────────────┬────────────────────────┘
                      │
┌─────────────────────▼────────────────────────┐
│         Runtime Layer                        │
│   Wallet session · permissions · audit       │
└─────────────────────┬────────────────────────┘
                      │
┌─────────────────────▼────────────────────────┐
│         Reasoning / Agent Layer              │
│   ZapBot · tool selection · plan · memory    │
└─────────────────────┬────────────────────────┘
                      │
┌─────────────────────▼────────────────────────┐
│         Tool Layer                           │
│   ~20 typed functions wrapping protocol APIs │
└─────────────────────┬────────────────────────┘
                      │
┌─────────────────────▼────────────────────────┐
│         Protocol Layer                       │
│   Quote · build · execute · status · prices  │
└──────────────────────────────────────────────┘

​
Protocol layer

Deterministic capabilities. No LLM dependency. Stable, typed, boring — and that’s the point. Responsibilities:
  • Quote retrieval
  • Bridge routing
  • Balance and position reads
  • Transaction construction
  • Transaction simulation
  • Gas estimation
  • Execution primitives

​
Tool layer

Turns protocol methods into AI-usable functions. Each tool exposes:
  • A clear name
  • Structured input + output schemas
  • Human-readable description
  • Execution constraints
  • Permission metadata
  • Safety notes when relevant
A model reasons more reliably over explicit tool contracts than over vaguely named raw methods. See Tools for the catalog.

​
Reasoning / agent layer

Where intent handling lives:
  • Understanding user goals
  • Breaking tasks into steps
  • Selecting tools
  • Carrying context across steps
  • Coordinating specialist agents
  • Deciding when to ask for confirmation
Example agent roles in production: advisor agent, execution agent, monitoring agent. DZap ships ZapBot as the default — see ZapBot.

​
Runtime layer

The space between a plan and a real action.
  • Wallet session state
  • Permissions and approval tiers
  • Auth boundaries
  • Execution policies
  • Scheduler-safe context
  • Auditability + controls

​
Interface layer

The same system surfaced through different interfaces:
  • MCP server
  • CLI
  • App UI
  • Internal copilots
  • Plugin / IDE integrations
The rule: many interfaces, one execution standard.

​
Execution flow

User intent
   ↓
Reasoning
   ↓
Tool selection
   ↓
Build plan
   ↓
Validate
   ↓
Simulate
   ↓
Request approval
   ↓
Execute
Each step is observable. Each step can be intercepted by runtime policy. The agent never executes a write tool without traversing the full pipeline.

​
Public-facing message

For external integrators, the framing is:
  • DZap handles DeFi primitives.
  • DZap AI exposes them as tooling for agents and apps.
  • MCP and client integrations provide the developer entry point.
  • Runtime + safety policies make execution safer and more predictable.
That keeps the story coherent without requiring readers to internalize the org chart.

​
See also

Safety & Execution

Execution classes and pre-execution checks.

ZapBot — How it works

The default agent’s loop, in detail.