Multi-agent AI trading, engineered for survival.
Single-model bots have nothing to veto them. iQntX has 31 other agents — and a watchdog that overrides them all. Here is the engineering story behind the 32-agent architecture, in operator-level detail.
The problem with single-model trading bots
A single-model trading bot is one model wrapped in a UI. When it is right, it makes money. When it is wrong, it makes the wrong trade. There is no second opinion. There is no veto layer. There is no agent that can refuse the order.
That works for a while. It does not work for thirty years.
Real hedge funds solve this with separation of concerns. iQntX inherits the same discipline.
The 32-agent architecture, top to bottom
CEO Agent
│
┌────────────────────┼────────────────────┐
│ │ │
MacroOfficer Strategy Risk Dept
(research desk) Dept (veto layer)
│
▼
Execution Dept
(orders + signatures)
│
▼
Intelligence Dept
(journal + self-optimize)
┌──────────────┐
│ Watchdog │ ← independent process
│ (L4 override)│ can halt CEO
└──────────────┘
The crucial design choice: the watchdog is not in the org chart. It runs as its own process, with its own permissions, watching the same metrics from outside. The CEO cannot demote it. The Risk Department cannot collude with it. Its job is to fail-close everything when invariants break — and that is the only authority it needs.
Communication: a Postgres message bus
Every agent communicates through public.agent_messages. Postgres LISTEN/NOTIFY wakes consumers in real time; the table itself is the durable record of every signal that ever travelled between agents.
| Column | Purpose |
|---|---|
id | UUID, primary key |
from_agent | Originator |
to_agent | Target (or * for broadcast) |
topic | Subject (stance.change, setup.proposed, risk.veto, …) |
payload | JSONB body |
idempotency_key | Dedupe |
parent_message_id | Conversation thread |
signed_by[] | FactChecker / DoubleChecker signatures |
created_at | When emitted |
processed_at | When consumed |
This single table is what you replay when you want to understand why the fund did what it did. Time-travel by SQL.
The 10-step lifecycle
Every agent inherits from AgentBase and implements the same loop:
- Read philosophy. Reload
context/philosophy.md(catches operator updates without restart). - Read own context. Load this agent's working notes from
context/<agent>/. - Read active stance. Pull the current CEO stance from
app_state. - Read the bus. Consume new messages on subscribed topics.
- Form a hypothesis. Apply skills (
skills/iqntx-*/SKILL.md) to inputs. - Consult. Call the LLM Router with the relevant skill.
- Propose. Emit a draft message to the bus (unsigned).
- Sign for FactChecker. Wait for FactChecker re-verification.
- Sign for DoubleChecker. Wait for blind second opinion.
- Journal. Write the decision and outcome to
context/journal/<date>/(markdown) andagent_journal(Postgres).
No agent skips a step. No agent is special. The Risk Gate runs the same 10 steps the Strategist does. The CEO runs the same 10 steps the StrategyBank does.
Three independent gates
A trade reaches the EA only after three independent gates sign:
Failed gates are not failures — they are journal entries. The Self-Optimizer reads near-misses every night and looks for patterns (e.g., "every time Macro is RISK_OFF and Strategist proposes a long, the Risk Gate vetoes" — useful feedback).
Subscription-first LLM routing
Routing one LLM call across 32 agents would be expensive. That is why iQntX runs subscription-first:
- Claude (CLI / Max x20) — primary for reasoning. CLI subprocess, no API cost.
- Codex CLI — primary for code-shaped tasks (regex, MQL5 fragments, JSON validation).
- Anthropic API — fallback for Claude when CLI is down.
- OpenAI API — fallback for Codex when CLI is down.
A circuit breaker trips a route after consecutive failures and moves the next call to the next route. A cost ledger journals every call (route, tokens, cost). You always know where the money went.
Why this beats a single-model bot
When a single-model bot is wrong, it stays wrong until it is killed. When iQntX is wrong:
- The Risk Gate vetoes setups that don't fit the current stance.
- The FactChecker invalidates stale signatures.
- The DoubleChecker fails to second the trade.
- The Macro Officer flips RISK_OFF and shrinks the strategy bank.
- The CEO escalates stance to DEFENSIVE or LOCKDOWN.
- The watchdog halts everything if any invariant breaks.
Six independent paths to "don't trade." A single-model bot has zero.
What to read next
- How a 32-Agent AI Hedge Fund Beats a Single-Model Bot
- Building Multi-Agent Trading Systems with Claude
- The Anatomy of a Drawdown
- Methodology — how decisions are made
Join the waitlist
We open cohorts in waves. Early-access pricing is locked the moment you join. Waitlist costs nothing and you can leave at any time.
You may also want
Frequently asked questions
Don't see your question? Email hello@iqntx.com — we'll add it.
What does 'multi-agent' actually mean here?
It means each AI agent has one job, runs the same 10-step lifecycle, and communicates with other agents via a Postgres-backed message bus — never via direct calls. No agent owns the whole trade. The architecture is closer to a microservices org chart than a single chatbot.
How do the agents communicate?
Through a Postgres LISTEN/NOTIFY message bus (table: agent_messages). Each agent reads from the bus, processes messages, emits new messages, and persists its journal entry. No direct function calls between agents — the bus is the single source of truth for inter-agent traffic.
Why does message-bus coordination matter?
Two reasons: replay-ability and resilience. Replay-ability — you can pause the bus, inspect every message ever sent, and replay history step by step. Resilience — if any agent crashes, the bus is unaffected; the agent is restarted and resumes from the last consumed message.
Does each agent have its own LLM call?
Yes. Each agent that needs reasoning calls the LLM Router with the specific skill (defined as a markdown file under skills/iqntx-*/SKILL.md). The router picks the route (Claude CLI, Codex CLI, Anthropic API, OpenAI API) based on availability and cost policy.
How do you keep 32 agents from going in circles?
Three mechanisms: (1) a max-depth on message chains, (2) idempotency keys on every message, (3) the FactChecker — every decision must be re-verified against current state before it gets signed. Loops can't survive a re-verification step.
Can I add my own agent?
Yes. New agents inherit from AgentBase and implement the 10-step lifecycle. They register with the SkillLoader, subscribe to message-bus topics, and start contributing on the next cycle. The Strategy Department especially is designed for expansion (tier 1–4 expansion agents already use this pattern).
What's the catch?
Cost of LLM calls. 32 agents reasoning at once is more expensive than one chatbot — which is exactly why iQntX is subscription-first (Claude Max x20 + Codex CLI), with API as fallback only. A typical operator running the system on a subscription pays for the subscription, not per-token.
Get on the waitlist.
Be first in line when private access opens. We onboard in waves so the system never gets in front of itself.