Run an agent that
rewrites itself.

Nerya is a self-evolving AI trading team that runs on your laptop. Skill-first and trading-native. One sentence is enough to get a working strategy package.

The strategy_author skill turns that prompt into a working strategy package in a single chat turn: trigger, sub-agent prompt library, candle source, account binding, risk limits, session ledger. You approve it, and it runs. After each run, the agent journals every decision, reviews every fill, reflects between sessions, and drafts upgrade proposals. The operator signs the diff or rejects it.

Why Nerya is different

One-liner install

# macOS / Linux
curl -LsSf https://raw.githubusercontent.com/NeryaAI/Nerya/main/install/install.sh | sh

# Windows PowerShell
iwr https://raw.githubusercontent.com/NeryaAI/Nerya/main/install/install.ps1 -UseBasicParsing | iex

The installer is idempotent. It:

1. installs uv if missing,
2. clones Nerya into ~/.nerya/src and runs uv sync --extra trading,
3. drops a nerya shim into ~/.local/bin,
4. initialises a workspace at ~/nerya-ws,
5. registers a host service so the local API boots with the machine on port 18317.

Beginner mode

nerya setup --tui      # rich text wizard: password, LLM key, gateway, memory, account
nerya setup --web      # same wizard in the browser at http://127.0.0.1:18317/setup

Every domain except the LLM model carries a safe default. Hit Enter through every prompt and you get a working install. Then open the dashboard and chat.

Manual quick start (no installer)

# 1. create a workspace
python -m nerya.cli.app init --workspace ~/.nerya

# 2. inspect installed skills
python -m nerya.cli.app skill list

# 3. run the vertical slice demo (simulation, no live keys)
python sdk/python/examples/price_tracker.py --workspace ~/.nerya

# 4. review the resulting strategy session
python -m nerya.cli.app strategy history btc_momentum --workspace ~/.nerya

# 5. reflect and generate evolution proposals
python -m nerya.cli.app reflect    --workspace ~/.nerya
python -m nerya.cli.app evolve     --workspace ~/.nerya
python -m nerya.cli.app proposals list --workspace ~/.nerya

Code lives in the repo. Runtime state (strategies, journals, sessions, approvals, memory, vault, proposals) lives in your workspace directory. Tarball it, grep it, or rm -rf it.

┌──────────────────────────── Nerya runtime ────────────────────────────┐
│   ┌──────────────────┐   ┌─────────────┐   ┌──────────────────────┐    │
│   │ Trigger router   │──►│ Nerya kernel│──►│ Skills runtime         │   │
│   │ schedule / NL /  │   │  agent loop │   │ registry + dispatch    │   │
│   │ webhook / gateway│   │  + planner  │   │ permissions + manifest │   │
│   └──────────────────┘   └──────┬──────┘   └───────────┬──────────┘    │
│                                 ▼                      ▼               │
│   ┌─────────────┐   ┌─────────────┐   ┌──────────────────────────┐    │
│   │ LLM gateway │   │ Subagents + │   │  Trading kernel           │    │
│   │ tiers +     │   │ Agent Team  │   │  intents → Risk Gate →     │   │
│   │ budget +    │   │ blackboard +│   │  Approval Gate →           │   │
│   │ adapters    │   │ mailbox     │   │  paper / live execution    │   │
│   └─────────────┘   └─────────────┘   └──────────────┬───────────┘    │
│   ┌─────────────┐   ┌─────────────┐   ┌──────────┐    ▼               │
│   │ Messaging   │   │ Security    │   │ MCP /    │  Strategy history   │
│   │ gateway     │   │ vault +     │   │ ACP      │  + journals         │
│   │ pipeline    │   │ signer +    │   │ bridges  │                     │
│   └─────────────┘   └─────────────┘   └──────────┘                     │
└────────────────────────────────────────────────────────────────────────┘
                                    ▼
┌───────────────────────── Nerya workspace (files only) ────────────────┐
│  state/ journals/ inbox/ outbox/ memory/ vault/ approvals/             │
│  strategies/<id>/{strategy.yml, limits.yml, history/, sessions/}       │
│  skills/{enabled.yml, installed/, pending/}                            │
│  scripts/{pending/, approved/, rejected/}                             │
│  evolution/proposals/                                                  │
└────────────────────────────────────────────────────────────────────────┘

A TeamRun is a durable team config that persists across turns. It carries the whole standing team and the rules that keep it honest.

• Typed members: strategy lead, market / on-chain / news / technical analysts, risk critic, execution planner, portfolio manager.
• Per-role skill allowlist + denylist. execution_planner cannot touch trading.
• Task board with dependencies, locks, priorities, owners.
• Mailbox for inter-agent messaging, plus a shared blackboard for evidence.
• Leader synthesis: the lead waits for required reports, resolves conflicts, emits a decision memo.
• Gates: plan-artefact, all-tasks-complete, verification, optional human approval.

After each closed session, reflection.py writes memory entries. nerya/evolution/ reads those entries and produces typed proposals.

learning_update         markdown patch to memory
prompt_patch            unified diff of an agent / subagent prompt
script_proposal         new script + manifest in workspace/scripts/pending/
skill_proposal          new skill directory in workspace/skills/pending/
trigger_route_patch     unified diff to workspace/triggers/routes.yml
strategy_config_patch   unified diff to strategies/<id>/strategy.yml
risk_limit_suggestion   advisory only; never overwrites limits.yml

workspace/memory/
├── global.md                    runtime-wide
├── mistakes.md                  reflection writes, agent reads
├── market_regimes.md            weekly review + news skill
├── skill_learnings.md           per-skill insights
└── strategy_learnings/<id>.md    per-strategy

Plain markdown. You can read it, diff it, version-control it. Nothing reaches a prompt without passing the firewall first. The built-in notebook is always on; optional plug-ins add memsearch (Milvus + embedding model) or agentmemory (external service).

Every capability lives under nerya/skills/builtin/<name>_skill/.

SKILL.md       when to use, workflow, examples
scripts/       executable helpers, JSON in, JSON out
references/    lazy-loaded methodology and research playbooks
templates/     code and config templates

All 25 built-ins ship today:

See the full skill reference: all 25 built-ins grouped by family, with when-to-use and flow for each.

TradeIntent → RiskGate → ApprovalGate → PaperExecution | LiveConnector
                                                 │
                                                 ▼
                          VirtualLedger · positions · PnL · reconciliation

• Risk Gate checks live status, limits, ledger, confidence, slippage, staleness, duplicates, conflicts. One failure stops the order.
• Approval Gate routes over-threshold intents to the operator queue.
• One JSONL session per run records trigger, context, decision, intent, risk verdict, execution, messages, outcome, review, and reflection.
• CCXT adapter for Binance, Bybit, OKX, Hyperliquid. On-chain: BSC (PancakeSwap v2), Solana (Jupiter), generic EVM via eth_account.

You don't have to wait for a release. Ask the agent.

The coding skill checks the CCXT bridge first (100+ venues already wired). If your venue is one of them, the agent registers an alias and you're done. If not, the agent drops a new workspace/providers/<id>/provider.py exposing a SPEC constant, calls ConnectorRegistry.reload_providers() for hot-reload, and verifies with connector_view. No daemon restart, no source-tree commit.

workspace/triggers/routes.yml maps a kind to a target: the main agent, a sub-agent, or a direct skill.

Idempotency keys, dry-run, and dedupe are built in.

Telegram, Discord, Slack, Feishu, WeCom, DingTalk, WhatsApp, and a generic webhook share one universal messaging surface.

GET  /gateway/platforms     # support matrix
POST /gateway/inbound       # normalized inbound messages
POST /gateway/send          # outbound via native or webhook channels

The SDKs never touch keys, exchanges, or RPCs. They are thin clients over the local daemon, which enforces every skill permission, risk gate, and approval gate.

from nerya_sdk import connect

client = connect()
client.triggers.emit(
    source="script",
    kind="price.breakout",
    payload={"symbol": "BTC", "price": 82_000},
    target="subagent:market_analyst",
    strategy_id="btc_momentum",
)

import { connect } from "@nerya/sdk";

const nerya = connect({
  baseUrl: "http://127.0.0.1:18317",
  caller: "script:my_bot",
});
await nerya.trading.submitIntent({
  strategy_id: "btc_momentum",
  account_id: "paper_main",
  market: "PAPER:BTCUSDT",
  side: "buy",
  size: 0.01,
  size_unit: "base",
  order_type: "market",
  confidence: 0.6,
  reasoning: "ts-sdk demo",
});

The recipes page has runnable Python and TypeScript examples: price-breakout slices, tiered news watchers, funding and whale triggers, and more.

• Go live the moment runtime.live_trading_enabled: true and the Approval Gate signs off. Until then, orders fill in simulation.
• No raw secrets reach agent context, only secret_ref and redacted previews. SecretVault resolves vault:// refs in-memory for one call, then discards them.
• No direct exchange calls from agent-authored code. Every external call goes through a registered skill, then a connector, then a signer.
• Scripts run in a sandbox: whitelisted imports, JSON I/O, manual approval before first run, no bypass of the Trading SDK or Risk Gate.
• Evolution can mutate prompts, scripts, skills, routes, and strategy configs, but never limits.yml, live_trading_enabled, signer policy, or secret policy.

• Vertical slice end-to-end: init → skill list → trigger → sub-agent turn → TradeIntent → Risk Gate → first fill → history → review → reflect → proposals.
• Agent Team Phase 1-4 live: durable core, templates, orchestrator, planner/kernel integration, skill + HTTP surface.
• CEX live-signed orders for Binance, Bybit, OKX, Hyperliquid. DEX swaps for BSC PancakeSwap v2 and Solana Jupiter.
• Cross-platform one-line installer with service registration.
• Dashboard (Next.js 14): Setup, Chat, Strategies, Self-Evolution, Memory, Skills, Workflows, Inbox, Portfolio, Gateway, Env Vault, Settings.
• Agent Team Phase 5: snapshot and replay.
• More native gateway adapters: Feishu rich cards, Discord slash commands, WhatsApp Business.