Agents

Agents are Forven's optional AI co-researchers. They draft hypotheses, write strategy code, run backtests, and produce post-mortems — but every decision routes back through the brain, and agents never place trades directly. The agent layer is free and runs on your own LLM key, so this page also covers where to manage agents and how to keep model spend bounded.

You manage them from the Agents hub at /agents. This is an operator surface: model assignment, terminal memory, MCP grants, and scheduler jobs all live here.

What agents do

Hypothesis drafting. Given a market observation, an agent produces a testable strategy specification — entry, exit, sizing, universe — that becomes a hypothesis the pipeline can act on.

Strategy authoring. The agent writes the Python implementation, registers it in the lab, and kicks off a quick_screen run (the public site calls this the screen gate).

Simulation and debugging. If a strategy underperforms in the gauntlet, an agent inspects the run and proposes parameter changes or structural edits.

Post-mortems. When a strategy fails a gate or a trade closes against thesis, the brain queues a failure_post_mortem task and an agent analyses why.

Work reaches agents as tasks (code_change, config_change, code_fix, post_mortem, strategy_archive, and others). You can watch every task — its tool calls, inputs, outputs, and errors — in the task queue.

What agents do not do

This is the most important section. The guardrails are enforced in code, not by convention.

• Agents never place trades directly. The execution-trader role only emits signals; fills are gated by the risk manager and the same approval gate that governs human-authored strategies.
• Agents never task each other. Forven uses a hub-and-spoke design: all agent output returns to the brain, and only the brain dispatches new work. There is no agent-to-agent chatter.
• Agents do not skip the gauntlet. No matter how confident an agent sounds, a strategy advances only if it survives walk-forward out-of-sample testing and clears the gates.
• Agents do not run unsupervised by default. Autonomous research and code changes flow through the approval queue unless you explicitly relax the policy.

The core agents

The hub manages seven core agents, each with role-specific tools and permissions. Custom strategy developers can be added alongside them.

The four roles the brain dispatches through the lifecycle are strategy-developer, simulation-agent, risk-manager, and execution-trader. The quant-researcher additionally receives post-mortem and data-quality tasks outside the stage lifecycle.

The Agents hub (/agents)

The hub at /agents is where you configure and inspect the agent layer. Each agent appears as a card with a collapsible detail panel.

• Model assignment. Pick a provider:model per agent (for example openai:gpt-5.2 or zai:glm-5.1). Changes persist immediately — there is no save button — and fall back to the default routing policy if you leave a model unset. See models & providers for the full routing model.
• Custom strategy developers. Create, rename, and delete your own developer agents in the Strategy Developers section. Protected core agents cannot be deleted.
• Terminal drawer. Open an agent's drawer to inspect its terminal memory, logs, and MCP servers (granted Model Context Protocol tool providers).
• Scheduler jobs. View and manage scheduler jobs with their cron expressions; deeper scheduling lives in scheduled routines.
• Sidebar settings. Poll interval, compact view, sound on task completion, and date format.

Steps — assign a model and add a custom developer

1. Navigate to /agents.
2. The core agents (Quant Researcher, Risk Manager, Brain, and the rest) are always visible.
3. To change a model, open an agent card and pick a provider:model from the dropdown — it saves on selection.
4. Scroll to the Strategy Developers section and click + Add Developer.
5. Enter a name (for example Custom ML Researcher) and select a model.
6. Click Create; the new developer card appears.
7. Click the card to open the settings drawer and edit its model or instructions.

What you'll see: the agent card list updates live, your new developer joins the roster, and any tasks it runs show up in the task queue with per-call cost attached.

Bring your own key

You supply the LLM key. Forven does not resell tokens. All calls route through a configurable provider priority list with automatic fallback on rate-limits and transient errors. Supported providers include:

• zai
• openai
• minimax
• lmstudio
• openrouter
• anthropic
• deepseek

The default fallback chain is zai → openai → minimax → lmstudio, and per-agent overrides sit on top of it. Keys live in your local keystore — they never leave your machine and never touch Forven's servers. The full provider, fallback-chain, and auxiliary-routing model is documented in models & providers (BYOK).

Cost discipline

The agent layer can burn through tokens fast if you let it, so Forven gives you hard ceilings.

• Daily cost cap (agent_daily_cost_cap_usd) — opt-in, default 0 (disabled). When set above zero, Forven sums every agent task's cost_usd for the current UTC day and blocks new task launches once the cap is reached. Blocked tasks stay queued until the next day or until you raise the cap.
• Deepdive per-thread cap (deepdive.cost_cap_usd, default $5) — the interactive strategy chat enforces a separate ceiling per thread.

Per-call cost is estimated from each provider/model's token rates and persisted on every task. The full mechanics live in cost controls.

Cost dashboards are coarse today. Treat them as a guide, not a precise ledger, and lean on the hard caps rather than after-the-fact reporting.

Caveats (beta)

• The AI Drop Zone panel on the Integrations page is a lightweight upload surface and is still a placeholder in this build.
• Agent model changes apply instantly with no confirmation step — double-check the provider:model you pick.
• Cost reporting is approximate; the hard caps are the reliable control.

---

Forven is a research tool. Agent-generated strategies and any numbers shown are illustrative, not predictive, and nothing here is financial advice. No agent can move real capital without passing the gauntlet and the operator approval gate.

Related

• The brain — the sole orchestrator agents report to
• Models & providers (BYOK) — provider routing and fallback
• Cost controls — daily and per-thread spend caps
• Approvals — the gate every agent action passes through