ARIA & the DAEMON Console
ARIA is DAEMON's built-in operator agent: a chat interface that can inspect the workspace, call typed tools, ask for approval, and execute real actions inside the IDE.
Overview#
The DAEMON Console lives in the right rail (toggle it with Ctrl+B, or move it to the bottom panel beside the terminal). Inside it runs ARIA, the operator layer for the IDE. ARIA is not a chatbot bolted onto the app. It is wired into DAEMON's main process through a registry of typed tools, so a natural-language request can turn into concrete workspace operations: open panels, read project state, inspect wallets, preflight token launches, create agent wallets, stage commits, write files, run engine actions, launch isolated swarms, and manage project memory.
A normal assistant tells you what to click. ARIA calls the same internal services the app uses, streams each tool call into the transcript, and pauses on approval cards before any write, signing, spending, or process-spawning action. The result is a command center where chat, wallet context, project state, approvals, and receipts live in one place.
/ for inline commands like /wallet balance, /wallet list, /solana cluster, and /launch tokens. Type > for navigation shortcuts such as >git, >settings, and >env.How an ARIA Turn Works#
- You send a request from a per-project chat session in the Console.
- DAEMON builds context from enabled chips: active file, project tree, git diff, terminal logs, wallet context, and approved project memory.
- ARIA chooses typed tools instead of inventing raw shell commands. Every tool has a schema, a risk level, and a handler in DAEMON.
- The transcript streams execution as plan rows, tool rows, approvals, patch proposals, memory recalls, and final text.
- Risk gates interrupt the loop when a tool can write, spend, sign, store keys, spawn agents, or launch processes.
- The result is persisted with chat history, tool metadata, plans, patch proposals, and memory suggestions.
What ARIA Can See#
ARIA receives a snapshot of the current DAEMON workspace with every turn. The user controls which context chips are included, so the prompt can stay narrow for quick commands or expand when the task needs more state.
| Context chip | What it contributes |
|---|---|
| Active file | The file currently open in the editor. |
| Project tree | The active project root and workspace shape. |
| Git diff | Current uncommitted changes when ARIA needs implementation context. |
| Terminal logs | Recent terminal output for debugging and setup tasks. |
| Wallet context | Default wallet, tracked wallet count, network, RPC provider, and Helius status. |
| Project Memory | Approved local facts such as commands, constraints, prior fixes, and decisions. |
Per-Project Sessions#
Every project gets its own chat sessions. Create, switch, rename, archive, or delete them. Titles are generated automatically from your first message, and conversations rehydrate from the local database when you restart the app.
Compounding Memory#
ARIA can remember durable project facts: package managers, build commands, test commands, project constraints, deployment targets, security notes, style preferences, prior failures, and fixes that should not be repeated. Memory is stored locally, can be listed, corrected, or archived, and is injected only when the Project Memory chip is enabled.
Secrets are rejected before storage. API keys, seed phrases, wallet secrets, personal data, and transaction-sensitive values are filtered by DAEMON's privacy guard and never become prompt memory.
The Tool Catalog#
ARIA works through a registry of typed tools. The important detail is not the count. It is the boundary: ARIA does not get arbitrary shell access. It can only use capabilities DAEMON exposes, validates, and risk-gates.
| Domain | What ARIA can do |
|---|---|
| Planning | Present ordered plans before acting and surface patch proposals as reviewable unified diffs. |
| Navigation | Open tools, panels, and files; run safe command-palette actions; read active project status. |
| Workspace | Create directories, scaffold files, and run DAEMON engine actions such as health checks, setup debugging, safety scans, and error explanation. |
| Settings | Change safe app settings, switch wallet infrastructure, enable or disable integrations, and open integration checks. |
| Wallet | Read portfolio state, generate wallets, set defaults, assign project wallets, store Helius keys, and transfer SOL behind sensitive approval. |
| Token launch | List launchpads, run preflight cost/readiness checks, and create token launches only after preflight passes. |
| Flywheel | Preview fee splits, configure locked on-chain split configs, and run claim/split/buyback flows. |
| Autopilot | Create trading mandates, arm unattended mainnet execution, disarm one mandate or all mandates, and list mandate status. |
| Git | Stage selected files or all changes and create a commit. ARIA never pushes. |
| Memory | Remember, recall, update, and archive durable project facts. |
| AgentStation | List and create local agent configs, create agent wallets, and scaffold agent projects. |
| Clawpump | List agents and skills, create agents, start or stop them, and send chat messages to an agent. |
| Agent Economy | List paid-agent profiles and resources, check policy, read receipts, register devnet identities, and execute gated paid calls. |
| RicoMaps forensics | Scan token mints, trace wallet funding chains, and expand suspicious wallet nodes for cabal, sniper, and bundle analysis. |
| Venum | Read live token prices, batch prices, and ranked Solana DEX swap quotes. |
| Hyperliquid | Read markets, books, funding, accounts, positions, orders, vaults; preview orders; place, cancel, modify, transfer, and update leverage behind approval. |
| Swarms | Launch, monitor, cancel, and collect results from parallel worktree-isolated Claude lanes. |
Plan Mode vs Build Mode#
- Build mode (default) - ARIA acts on your request immediately.
- Plan mode - ARIA presents an ordered plan first and waits for one approval before write tools run.
Plan approval is not a bypass. Sensitive tools still require their own typed confirmation even after the plan is approved.
Safety Model#
- Read tools auto-run - navigation, wallet reads, market reads, quote reads, memory recall, and forensic scans execute without prompts.
- Write tools show approval cards - commits, file scaffolds, settings changes, memory writes, config changes, and process launches wait for inline approval.
- Sensitive tools require typed confirmation - wallet generation, key storage, SOL transfers, token launches, flywheel actions, paid calls, live trading, agent-wallet creation, and swarm launches require a deliberate typed phrase.
- Mainnet is explicit - when wallet infrastructure points at mainnet-beta, summaries and approval cards carry a
[MAINNET]marker. - Execution fees are visible - fee-bearing actions quote the fee on the approval card before anything runs.
- Patch proposals are scanned - proposed diffs are checked for sensitive paths, secrets, and safety findings before the keep/discard decision.
- No autonomous pushes - ARIA can commit locally, but pushing and merging stay human-controlled.
Agent Swarms#
Ask ARIA to fan a job out and it launches 2-12 parallel tasks, each in its own isolated git worktree and branch, each driven by an independent Claude lane (up to 4 run concurrently). Every lane writes a RESULTS.md summary at its worktree root; worktrees are cleaned up automatically, and merging lane branches is a deliberate manual step in the Git panel.
Swarms can optionally run a BrainBlast pre-flight. In that mode, each lane researches the task first and records a risk report. If a lane hits a critical integration risk, DAEMON blocks that lane before code is written.
ARIA vs the DAEMON Bridge#
ARIA is the built-in operator inside DAEMON. The DAEMON Bridge exposes a smaller, external MCP surface so agents from Cursor, Claude Code, or other clients can request DAEMON actions. Bridge calls use the same approval gate, but they do not get ARIA's full UI-driving catalog.
| Surface | Capabilities |
|---|---|
| ARIA Console | Full operator catalog: workspace, settings, wallet, launches, swarms, agents, forensics, market tools, memory, and git commits. |
| DAEMON Bridge | Allowlisted external tools: project status, wallet, token launch, and memory actions, filtered by enabled packs and gated in DAEMON. |
Current Boundaries#
- ARIA does not have an arbitrary raw-shell tool. Command execution is exposed only through typed DAEMON actions or isolated swarm lanes.
- ARIA can create local git commits but cannot push to a remote.
- Token launches must run preflight first, and creation re-runs preflight before the on-chain call.
- Live Hyperliquid order placement should be preceded by a dry-run preview, then a sensitive approval.
- Project memory is local, source-backed, and secret-filtered.
Model Lanes#
On the free Light tier, ARIA runs through your own Claude setup (BYOK) with three lanes: fast (Haiku), standard (Sonnet, default), and reasoning (Opus). Pro and above route through DAEMON AI Cloud with five hosted lanes: auto, fast, standard, reasoning (Operator+), and premium (Ultra). Pick the lane from the model dropdown in the Console header.