AI Drop Zone

The AI Drop Zone is where an AI client you already use — Claude Code, Claude Desktop, Cursor, Codex CLI, or any MCP or HTTP client — drives Forven: writing strategy files, registering them, backtesting, validating, and promoting them through the real gates. You find it at Integrations → AI Clients.

The client's work is grouped into sessions, written ADZ-0007, so after an hour of iterating you can answer the question that matters: what did it actually test, and what came out?

The AI Drop Zone before any client has connected. Sessions and activity fill in once one starts working.

The page

Integrations has two tabs: AI Clients (outside assistants connecting into Forven — this page) and Agent Tool Servers (Forven's own agents connecting out to external tools — below).

The AI Drop Zone header shows a Backend status dot — if it's red, MCP tool calls fail too, because the MCP server talks to Forven through that API — and how many sessions are open. Pick one in Session to watch it, start one with + New (an optional label and objective), or Close it.

Connect an MCP client

21 MCP tools · the full loop: register → backtest → optimize → robustness → promote.

Each client gets its own snippet and the file it belongs in.

Full guide opens the MCP setup guide that ships with Forven. Per-client details and troubleshooting are on MCP server.

Connect over HTTP (no MCP)

Same tools via the REST API. For clients that don't speak MCP, scripts and CI: a small CLI (python -m forven.agent health | list | backtest | enqueue | wait-paper, Copy CLI), Python and TypeScript snippets, and an Endpoints (any language) table. Auth is only needed if the backend is exposed beyond localhost — send x-api-key / x-operator-key, or set FORVEN_API_KEY / FORVEN_OPERATOR_KEY.

Active Session and Recent Activity

• Active Session — for the session you picked: Strategies tagged to this session and Gauntlet runs in this session.
• Recent Activity — across all sessions, refreshed every 5 seconds: Latest intake (newly registered strategies and their stage) and Latest runs.

Strategies that came in this way also carry an AI Drop Zone chip in The Forge.

Manual Fallback

Do it by hand. Register strategy file: enter an absolute path, click Scan — AI-generated strategies must pass the AST safety gate first — then Register. Run backtest: a strategy ID and a dataset such as BTC/USDT-1h, then Run.

Sessions

A session is a grouping tag, not an account or a permission:

• IDs run in order: ADZ-0001, ADZ-0002, …
• Over MCP they're automatic. A session opens on the client's first register or backtest call, tags everything after it, and closes when the client disconnects. A server-side sweep also closes sessions idle for about 6 hours (FORVEN_DROPZONE_IDLE_TTL_HOURS), so open means genuinely in use.
• You can still open one yourself with a label and objective, or pass a session_id to resume one.
• A session is active or closed. Closing is one-way: a closed session is kept for review but can't be reopened or tagged again.

Sessions scope queries; they don't control access. Who can do what is decided by the backend's auth, not the session.

Where strategies land

A registered .py file is checked by the registration validator and the AST safety gate, and its code only ever runs inside the locked-down strategy worker. Then it lands in one of two places:

• quick_screen — the start of the normal pipeline: quick_screen → gauntlet → paper → live_graduated.
• The graveyard, archived as untestable — if it crashes, leaks look-ahead, or fails certification. The response gives the reason; fix the file and register it again.

Registering never promotes. A strategy reaches paper only by passing the gauntlet and the door into paper (then a free slot in the paper pool), and live only through the stricter paper → live gate and your typed GO LIVE.

The loop an AI client runs

The MCP server's own instructions give the client this loop:

1. forven_get_context — overview first, then the template and gotchas sections.
2. forven_get_quant_skills for priors; and before using any input beyond candles, forven_get_data_readiness for the market.
3. Write a strategy .py into the workspace, then forven_register_strategy_file with its absolute path.
4. forven_run_backtest and iterate on the design.
5. forven_run_optimization, then bake the winning parameters into the file's default_params.
6. forven_run_robustness — the persisted validation suite the paper gate reads — and poll forven_get_robustness_result.
7. forven_get_gate_report, then forven_promote_strategy when every gate is green — or when the only failed gate is holdout_pending, because that attempt submits the one-shot held-back test. By default the held-back test runs at paper → live, so on the way into paper you'll only see holdout_pending under Strict paper or with Held-back test runs at set to Gauntlet to paper.
8. forven_get_session to review everything the session tagged.

Never with force=true: a genuine rejection is the system working. Every tool is in the MCP tools reference.

With the default settings, promotion to paper goes through the research door: a strategy that isn't broken or clearly losing reaches paper, and the deflated Sharpe, walk-forward, jitter, regime-split and held-back checks are recorded there and enforced at paper → live. So holdout_pending shows on the paper hop only when the held-back test runs before paper (Strict paper, or Held-back test runs at → Gauntlet to paper). If the paper pool is full, a passing strategy waits for a slot (paper_queue_full) and is admitted automatically.

Agent tool servers

The other direction. Most installs never need anything here.

The Agent Tool Servers tab is the reverse: you register an external MCP server (a web search, a filesystem, a ticker API) and its tools become callable by Forven's own agents. Having none is the normal state. Setup is on MCP server; grant a server to an agent on its drawer's Tools tab under Agents.

The underlying API

Each MCP tool is a thin wrapper over the local backend (http://127.0.0.1:8003 by default), so you can drive the Drop Zone directly:

If the backend has FORVEN_AUTH_REQUIRED=true, send the x-api-key and x-operator-key headers.

Good to know

• Overrides are per run. Parameters passed to one backtest never change the strategy's saved defaults; bake winners into the file.
• Closed is closed. New work gets a new session.
• Registration isn't promotion. Nothing reaches paper without surviving the gauntlet and the gates.

Related

• MCP server — client configs, auth and troubleshooting
• MCP tools reference — all 21 tools
• Connect Claude Code or Cursor — the walkthrough
• Deep-dive strategy chat — refine one strategy interactively