WP-07 — Meta-Agent Trading Stack: DAG Execution Engine

The Meta-Agent Trading Stack is the runtime that executes Treeova's autonomous trading agents. Where the conviction methodology (WP-01) describes what an agent reasons about, this whitepaper describes how the agent's reasoning is actually executed — including the safeguards that prevent the runtime from enabling outcomes the conviction layer would not endorse.

See the product surface for this methodology: Feature page for Navigator.

Each agent is modeled as a directed acyclic graph of tool invocations. A node is a tool call; an edge is a data dependency. Modeling agents this way makes the actual structure of the reasoning explicit: which tools must run before which others, which can run in parallel, and which converge on a downstream synthesis.

The executor topologically sorts the DAG into ordered execution phases. Within a phase, nodes execute in parallel — they have no mutual dependencies. Across phases, ordering is strict — a later phase begins only when every node in earlier phases has finished.

The benefit is concurrency without race conditions: independent tool calls run together, dependent tool calls wait for their inputs, and the run's structure is auditable by reading the phase log.

• Stall detection. Runs that fail to make forward progress within their budget are terminated rather than allowed to spin.
• Shotgun prevention. Attempts to fan out into many parallel tool calls without justification are rejected; the executor requires a coherent plan before it will widen.
• Goal sprint. When drift from the agent's declared goal is detected, the executor steers the agent back toward the goal rather than letting the run wander.
• Self-healing. Recoverable tool failures — transient API errors, retried-with-backoff conditions — are healed without human intervention, with the recovery recorded in the run log.
• Symbol pinning. Execution-class tools (paper trades, flash discounts, alerts) act only on symbols the agent has actually researched in the same run. Acting on a symbol that appeared only in passing context is refused at the runtime layer.

Sensitive actions — live trading, billing-affecting actions, admin overrides — pass through human-in-the-loop gates. The executor surfaces the proposed action, blocks the run until the gate resolves, and records the resolution alongside the rest of the run.

The agent cannot bypass the gate by retrying, rephrasing, or decomposing the action. The gate is a property of the runtime, not a hint to the model.

Every run produces a structured record: the DAG, the assembled phases, the inputs and outputs of each node, the safeguards triggered, and the human-in-the-loop resolutions. This record is the basis of both the agent's own reinforcement-learning signal and any after-the-fact review by a human operator.

• The contents of the tool registry and any alias mappings.
• The parameter shapes of execution-class tools.
• The modality security gate's internal rules.
• Throttle matrices and per-tool rate limits.
• The exact prompts used by the agent loop.

• The runtime enforces safeguards; it does not guarantee profitable trades. Profitability is a market outcome, not a runtime property.
• Symbol pinning prevents wrong-symbol execution but cannot prevent a poor decision on a correctly-pinned symbol.
• Human-in-the-loop gates depend on responsive operators. Unresolved gates leave runs blocked by design — the runtime will not auto-approve to make progress.
• DAG execution captures the structure of an agent's reasoning, not the quality of it. Quality is governed by the conviction and risk layers, documented separately.
• Nothing in this whitepaper is investment advice. Trading options involves substantial risk of loss; users should review Treeova's risk disclosures.