Blog Part 2: Loop Engineering for Practical Trading Agents

[YangletLiu]

Objective

Continue the Agentic Trading Lab blog series with a second post focused on loop engineering: how to turn a one-shot LLM trading decision into a bounded, stateful, testable, and risk-controlled trading process.

Blog: Agentic Trading, Part 1: Build a Simple Trading Agent with Commonstack APIs https://medium.com/@kuailedefcl/agentic-trading-part-1-build-a-simple-trading-agent-with-commonstack-apis-42b413365906

Owners: @JinBoatus1 and @Allan-Feng

Part 1 introduced the minimal loop—observe, analyze, execute, and update—and showed how the surrounding application validates the model output and carries portfolio state into the next cycle. Part 2 should explain how to engineer that loop for a practical trading agent.

Core thesis

Prompt engineering shapes one model call. Loop engineering defines the complete control cycle around the model:

trigger → build state → propose action → verify → risk gate → execute → observe outcome → update memory → repeat or stop

The model may propose an action, but the system must control what is allowed, what is executed, what evidence is recorded, and when the loop terminates or escalates.

Recommended architecture

Use a two-timescale design.

1. Fast online loop

• Wake up on a schedule, market event, news event, or risk alert.
• Build a typed state from market data, portfolio state, user constraints, and recent memory.
• Generate a structured action proposal: BUY, SELL, HOLD, or ADJUST.
• Validate schema, symbol, quantity, data freshness, and action expiry.
• Apply deterministic risk controls: position limits, concentration limits, stop-loss rules, duplicate-order checks, trading-session rules, and kill switch.
• Execute only approved actions through a broker or paper-trading adapter.
• Record order status, fills, portfolio changes, latency, rationale, and evidence.

2. Slow offline loop

• Replay decisions and failures.
• Evaluate decision quality, risk-rule adherence, turnover, drawdown, slippage, and model/tool failures.
• Update episodic memory and reusable skills.
• Compare prompt, model, workflow, and specialist-agent variants.
• Promote changes only after backtesting and paper-trading evaluation.

Blog scope

The post should cover the following points.

1. Prompt engineering vs. loop engineering

   • Prompt engineering controls a local response.
   • Loop engineering controls repeated behavior over time.
   • The main engineering object is the external state machine, not a longer prompt.

2. Anatomy of a practical trading loop

   • Trigger
   • State builder
   • Signal/research layer
   • Structured decision contract
   • Deterministic validator
   • Risk and compliance gate
   • Execution adapter
   • Monitoring, memory, and replay

3. Memory and context management

   • Durable policy memory: mandate, universe, limits, and strategy.
   • Episodic memory: recent decisions, fills, failures, and thesis changes.
   • Working context: only information required for the current decision.
   • Do not keep appending raw news, tool traces, and old reasoning into one unbounded prompt.

4. Specialist-agent roles

   • Use the agency-agents/finance repository as inspiration for role definitions, especially investment researcher, financial analyst, and controller.
   • Treat these as modular specialists, not as a complete trading system.
   • Prefer parallel research with serialized integration and one final execution gate.

5. Failure handling and recovery

   • Invalid JSON or unsupported action → reject.
   • Stale or inconsistent state → hold and refresh.
   • Tool/API failure → retry within a fixed budget, then escalate.
   • Partial fill or broker rejection → reconcile before the next decision.
   • Repeated failures, abnormal turnover, or risk-limit breach → freeze the agent.

Practical demo

Build one small, reproducible paper-trading example that extends Part 1.

Suggested workflow:

market/event trigger
    → state builder
    → LLM action proposal
    → typed validation
    → deterministic risk gate
    → simulated execution
    → portfolio update
    → event log
    → next cycle

The demo should include:

• A strict action schema.
• Data timestamps and freshness checks.
• At least three hard risk constraints.
• An idempotency key or duplicate-order guard.
• A bounded retry/stopping rule.
• A replayable event log.
• One example showing an action rejected by the risk gate.

Keep the demo in paper-trading mode; no live capital or unrestricted broker access.

Division of work

@JinBoatus1

• Draft the narrative and opening example.
• Define prompt engineering vs. loop engineering clearly.
• Review the loop-engineering and agent literature.
• Map the finance specialist roles into the trading workflow.
• Prepare the first complete blog draft.

Allan

• Audit the current AgenticTrading codebase for reusable components.
• Implement the minimal gated loop demo.
• Add logging, stopping rules, and one failure-recovery path.
• Produce the main architecture figure and code snippets.
• Confirm that the example runs from a clean environment.

Joint

• Integrate prose, diagram, and implementation.
• Keep terminology consistent with Part 1.
• Test every code block.
• Submit the draft and demo in one PR.

Deliverables

• Blog draft: approximately 1,800–2,500 words.
• One main architecture diagram: fast loop + slow loop.
• One comparison table: prompt engineering vs. loop engineering.
• One runnable paper-trading loop example.
• One failure-mode table with concrete mitigations.
• References and acknowledgements.
• PR linking the blog draft, source figure, and demo code.

Acceptance criteria

• The article is a natural continuation of Part 1 rather than a standalone survey.
• The central contribution is a practical loop architecture, not a collection of agent personas.
• Risk validation and execution control remain external to the LLM.
• The implementation is bounded, replayable, and testable.
• The demo includes at least one rejected trade and one successful cycle.
• The post avoids claims of profitability or production readiness without evidence.

Suggested references

• Loop engineering: https://arxiv.org/abs/2607.00038
• Finance role templates: https://github.com/msitarzewski/agency-agents/tree/main/finance
• ReAct: https://arxiv.org/abs/2210.03629
• Reflexion: https://arxiv.org/abs/2303.11366
• Anthropic agent best practices: https://code.claude.com/docs/en/best-practices
• Anthropic memory and context: https://code.claude.com/docs/en/memory
• OpenAI Agents SDK: https://openai.github.io/openai-agents-python/
• OpenAI function calling and structured outputs: https://platform.openai.com/docs/guides/function-calling

Proposed article title

Agentic Trading, Part 2: Loop Engineering for Practical Trading Agents

Alternative subtitle:

Why a reliable trading agent needs more than a good prompt