Single-shot prompting is dead for serious quant work. You ask an LLM for an alpha factor, it gives you momentum or RSI, you backtest it, it fails. You prompt again. Nothing connects. Nothing learns. Nothing improves.
Loop engineering is what comes next. Coined by practitioners in mid-2025 and formalized by Google engineer Addy Osmani in June 2026, it's the discipline of designing AI systems that don't just respond once - they act, observe the result, decide what to do next, and repeat until a goal is actually met. As Peter Steinberger put it: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."
For quants, this reframes the entire research workflow. You stop being the person who writes factor code. You start being the person who designs the system that writes, tests, and iterates on factor code. The leverage moves from the quality of a single prompt to the architecture of the feedback loop.
Here's how to build it. But before that who am i ?
---
about me : I am Venus (open-source-believer, so spitting out internal secrets on X), a Senior Quant Systems Architect and Backend Engineer experienced in building startups from 0→1 and scaling products from 1→100 across AI, cloud, and fintech x defi infrastructure. dm's are open to connect. Let's get back to article.
---
## What Loop Engineering Actually Is ?
A loop in agentic AI is a repeating cycle: the agent perceives its environment, reasons about what to do, acts, observes what happened, and feeds the result back into the next iteration. The cycle runs until a termination condition is met - a task complete, a quality threshold passed, a stopping criterion triggered.
This is the core four-stage cycle :
PERCEIVE → REASON → ACT → OBSERVE → (loop back)
It traces back to the ReAct pattern (Yao et al., 2023) : Reasoning + Acting interleaved so the agent can think about why an action failed before retrying. A single-shot prompt is like firing an arrow with your eyes closed. A loop is like adjusting your aim after each shot based on where the last one landed.
For quant research, the four stages map directly :
PERCEIVE = ingest market data, factor library, prior backtest results
REASON = generate hypothesis, decide which factor type to explore
ACT = write factor code, run backtest, compute IC/ICIR
OBSERVE = evaluate metrics, extract failure mode, update memoryThe loop continues until ICIR > 0.5, half-life > 30 days, and IC is stable. You don't prompt once. You design the system that prompts itself.
---
## The Three Loop Types Every Quant Needs
Not all loops are equal. Quant research needs three nested loop types, each operating at a different timescale:
from anthropic import Anthropic
import pandas as pd
import numpy as np
import json
import time
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
client = Anthropic()
@dataclass
class LoopState:
"""
Shared state passed between all loop iterations.
This is the 'environment' the agent perceives each cycle.
Critical design principle: all state is explicit and inspectable.
No hidden side effects. Every loop iteration reads and writes here.
"""
# What has been tried
attempted_factors: List[Dict] = field(default_factory=list)
approved_factors: List[Dict] = field(default_factory=list)
failed_factors: List[Dict] = field(default_factory=list)
# What was learned
failure_patterns: List[str] = field(default_factory=list)
success_patterns: List[str] = field(default_factory=list)
# Current iteration context
current_hypothesis: str = ""
current_code: str = ""
current_metrics: Dict = field(default_factory=dict)
# Loop control
iteration: int = 0
max_iterations: int = 50
target_approved: int = 10
# Termination signals
should_stop: bool = False
stop_reason: str = ""
class QuantLoopEngine:
"""
Three-tier loop architecture for autonomous quant research.
OUTER LOOP (Strategy level):
Runs until target_approved factors are found.
Manages domain rotation, memory consolidation.
Timescale: Hours to days.
INNER LOOP (Factor level):
Runs until one factor is approved or max debug attempts exceeded.
Handles generate → test → debug → approve/reject.
Timescale: Minutes.
MICRO LOOP (Code level):
Runs until code executes without errors (max 3 attempts).
Syntax errors, missing columns, type mismatches.
Timescale: Seconds.
This nesting is the key architectural insight:
each loop has its own termination condition and feedback signal.
"""
def __init__(self, market_data: pd.DataFrame):
self.data = market_data
self.state = LoopState()
# Loop config
self.max_debug_attempts = 3 # Micro loop
self.max_factor_attempts = 5 # Inner loop
self.icir_threshold = 0.5 # Approval gate
self.halflife_threshold = 30 # Approval gate
# Conversation history per agent (persists within inner loop)
self.hypothesis_history = []
self.factor_history = []---
Generated by Thread Navigator
Press ⌘ + S to quick-export