// Insights
Writing
Field notes on production AI and quantitative finance, what actually transfers from research to the desk.
For a long-horizon agent, full history is dead weight
GPT-5 itemizing expenses through enterprise tools completed 71.0% of the work on full conversation history and 91.6% on a pruned, summarized context, using 2.7x fewer tokens and 2.5x less time. Less context, better agent, the measured payoff of the lost-in-the-middle geometry.
Lost in the middle: a position bias that predates training
Language models read the start and end of a long context well and the middle poorly. A new exact theory shows the U-shaped curve is present at random initialization, before any training or positional encoding. For RAG and long-document work, where you place the key passage is a design decision.
What agent memory actually costs to run
The first systems characterization of agent memory prices ten systems on one H100. Energy per correct answer spans 47x, driven by memory construction rather than query-time serving, a cost every accuracy benchmark hides.
Let the market choose which source your RAG trusts
A frozen Llama-3.1-8B with an external Bayesian source-memory, updated from matured residual returns, lifts held-out macro-F1 from 0.438 to 0.471 and a diagnostic portfolio Sharpe from 0.52 to 0.84 net of costs. Adapting the retriever beat fine-tuning the reader.
Building the agentic enterprise: a field guide
Everyone is shipping agents and most will stall after the demo. The architecture that holds up in production, and the pre- and post-launch discipline that decides which agents survive, with the evidence attached.
WorkstreamBench: can an agent build the model, not just the answer
An evaluation of LLM agents on end-to-end financial spreadsheet workstreams, graded on accuracy, formulas, and format against professional standards. The best agent scores 69.1 of 100 and degrades sharply past a few chained calculations. The artifact, not the answer, is the test.
FinToolBench: 760 real tools, and the best agent executes a third
The first executable benchmark for financial tool use replaces mock APIs with 760 runnable tools and 295 real queries. Best-in-class execution success: 32.54%. The gap between calling a tool and completing the job is the whole finding.
Nowcasting port trade from orbit: levels lie, changes travel
SAR imagery plus nighttime lights nowcast monthly US port trade at R-squared 0.945, from public data alone. The transferable lesson is sharper: absolute levels break outside the training domain while percentage changes recover almost perfectly.
Fin-RATE: models ace the document and fail the workflow
A benchmark shaped like actual analyst work, single-filing reasoning, cross-entity comparison, longitudinal tracking, finds accuracy dropping 14 to 19 points the moment a task spans companies or quarters. The degradation lands where the job lives.
Implementation risk: same strategy, five engines, 3.71 points of divergence
A paper finally measures how much backtest results depend on which engine ran them: zero divergence without costs, up to 3.71 percentage points with them, rising with turnover. The engine is part of the model, and now there is a protocol for saying so.
A stress gauge from the cross-section: simple model, fragile-market features
Eleven interpretable fragility signals from the equity cross-section, an L1 logistic regression, and a calibrated one-month-ahead stress probability: AUC 0.800 against 0.752 for the volatility benchmark. The instrument design matters more than the model.
DeepSeek-V4: a million tokens of context, on weights you can own
Two MIT-licensed MoE models, V4-Pro at 1.6T parameters and V4-Flash at 284B, ship with 1M-token default context and a production sparse-attention design. For document-heavy quant work that cannot leave the building, the cost calculus just moved again.
HalluBench: your hallucination detector degrades with your knowledge graph
A benchmark for hallucination detection in KG-augmented financial QA over 10-Ks delivers an uncomfortable result: the best detectors lose up to 84% of their discriminative power when the graph itself contains noise. The detector inherits the infrastructure's flaws.
DeePM: robustness as an objective, not an afterthought
A deep portfolio manager that optimizes a differentiable proxy for entropic value-at-risk over its worst historical windows, with causal delay handling and a macro graph prior. Twice the risk-adjusted return of classical trend, by the paper's account, with the design choices doing the work.
One agent, full context: the information-theoretic case
Tran and Kiela ground the single-agent argument in the Data Processing Inequality: every agent-to-agent handoff can only lose information, so at equal token budgets one agent with full context wins. The experiments agree, and the practitioner doctrine got there first.
Zero-shot foundation models beat the USDA on softs
Time-MoE improves on USDA benchmarks by 54.9% on wheat and beats futures-based forecasts on three of four commodities, with no forward-looking inputs. The December verdict on returns survives; commodity prices are a different animal.
AutoResearch: a hundred experiments while you sleep
Karpathy's 630-line loop puts an agent in charge of ML experimentation: propose a change, train for exactly five minutes, keep it only if the metric improves. It works because the evaluator cannot be gamed, which is precisely the property a backtest does not have.
Conformal VaR under drift: a calibration layer the regulator can read
Wrap any VaR forecaster in a conformal layer weighted by time decay and regime similarity, and the exceedance rate holds near target under market drift. The honest result: time-weighting is the strong default, regime-weighting earns its keep in stress.
A-RAG: give the model the search box, not the pipeline
Expose three retrieval primitives, keyword search, semantic search, chunk read, directly to the model and let it decide granularity. On multi-hop QA the gains are dramatic and the token bills drop, with the advantage growing as models improve.
SAIFIN: satellites, sentiment, and the committee that explains itself
A peer-reviewed multi-agent framework fuses market data, news sentiment, and satellite-derived indicators through specialized LLM agents into explainable commodity-trading recommendations. The orchestration is the contribution; the governance reading cuts both ways.
AGENTS.md, measured: the convention is a tax
ETH Zurich runs the first controlled evaluation of repository context files: LLM-generated AGENTS.md files reduce coding-agent success while raising costs 20-23%, and even good human-written ones buy ~4% for almost as much spend. Standardized in December, measured in February.
Robust combinations for the yield curve: Nelson-Siegel meets the forest
A Treasury forecasting framework that fuses factor-augmented Nelson-Siegel with random forests through distributionally robust combinations weighted by worst-case error. No single model owns the curve; the combination policy is the model.
Agentic reasoning, unified: a map for deciding where agents belong
A 29-author survey organizes agentic reasoning into three layers, foundational, self-evolving, and collective, and splits inference-time orchestration from post-training optimization. The taxonomy doubles as a decision tool for where agentic loops help a research desk and where they multiply p-hacking.
Pontryagin projection: dynamic allocation that respects the physics
A two-stage solver for portfolio choice under parameter uncertainty: backpropagate through the simulator to learn a policy, then project it onto the optimality conditions the math says must hold. Structure does what brute-force RL cannot.
Look-Ahead-Bench: the cardinal sin of backtesting gets a meter
A benchmark that measures whether an LLM is silently cheating on history: standard models lose 15 to 22 points of alpha the moment the test period crosses their training cutoff. Point-in-time models hold steady. The audit is now runnable.
Sort on the bound, not the point: uncertainty-adjusted ML portfolios
ML factor pipelines throw away the one number the model produces for free: its own uncertainty. Sorting stocks on prediction bounds instead of point forecasts lifts Sharpe ratios mainly by cutting volatility, which is the improvement desks actually get paid for.
When do more agents help? DeepMind runs the experiment
180 controlled configurations across five architectures, six benchmarks, and three model families produce the first quantitative answer: coordination turns negative once a single agent clears 45%, independent agents amplify errors 17.2x, and a four-metric model predicts the right architecture 87% of the time.
Hindsight: typed memory beats a bigger window
Four logical memory networks, world facts, experiences, entity summaries, evolving beliefs, with retain, recall, and reflect operations. On LongMemEval it lifts a 20B open model from 39% to 83.6%, past full-context GPT-4o. The schema is the contribution.
MCP joins the Linux Foundation: tool access becomes infrastructure
Anthropic donated the Model Context Protocol to the new Agentic AI Foundation, co-founded with Block and OpenAI, with Bloomberg among the backers. For regulated firms, neutral governance is the feature that unblocks standardization.
RACE: when the reasoning and the answer disagree
A hallucination detector built for reasoning models: four signals spanning the trace and the answer, fused into one score. The right number for the wrong reason is finally a measurable event.
Time-series foundation models in finance: what transfers and what does not
The first comprehensive test of TimesFM and Chronos on 18 million daily returns answers the question every quant has been asking: zero-shot transfer fails outright, finance-native pretraining recovers most of the gap, and a tuned gradient-boosted tree still wins on fit.
Memory as action: the agent learns what to forget
MemAct folds context management into the agent's own policy: deleting and inserting working memory becomes an action the model takes, trained end-to-end with a segmented RL algorithm built for the job.
Rethinking retrieval: vectors beat graph-walking on SEC filings
The first systematic head-to-head of vector-based agentic RAG against hierarchical node-based reasoning over 1,200 SEC filings, with latency and win rates reported. The boring architecture wins, again.
LangGraph 1.0: agents that survive a restart
The first stable release of the durable agent-orchestration framework brings automatic state persistence, resumable checkpoints, and first-class human-in-the-loop APIs. The features nobody demos are the production ones.
Kimi K2 Thinking: 300 tool calls on weights you can own
Moonshot's trillion-parameter MoE sustains 200-300 sequential tool calls, ships native INT4, and beats GPT-5 on agentic-search benchmarks, under a modified MIT license. The open-weights agentic gap just closed further.
Agentic RAG for fintech: paying latency for precision
A four-agent retrieval pipeline with query reformulation, sub-query decomposition, acronym resolution, and cross-encoder reranking. The unglamorous fixes win again, at a price the paper is honest about.
TiMi: the LLM writes the bot, the bot trades alone
A trading-agent system that keeps language models entirely out of the execution path: agents write and tune deterministic bots offline, the bots trade at 137ms with 5ms of internal logic. The decoupling is the contribution.
From text to alpha: the signal is in what firms stop talking about
An LLM that tracks how firms shift emphasis across metrics in earnings calls turns an insignificant keyword signal into a significant one. The method matters more than the modest alpha.
GDPval: measuring models against working professionals
OpenAI's benchmark grades frontier models against real deliverables from professionals averaging 14 years of experience. The best model wins or ties 47.6% of blind comparisons. What that number means, and how to build your own version, matter more than the headline.
CAFPO: deep RL on learned factors, before costs
Conditioning an autoencoder on 94 firm characteristics and handing the latent factors to a PPO allocator beats every classical baseline out of sample. The table rewards a careful read more than a headline.
An LLM alpha factory meets the multiple-testing problem
A framework where an LLM writes formulaic alphas from price, technical, and sentiment inputs, feeding a transformer for stock prediction. The factory works. The audit discipline around it is the actual product.
AgentSight: watching agents from the kernel
An open eBPF framework that observes AI agents from outside their code, correlating intercepted LLM traffic with kernel events at under 3% overhead. Independent verification, finally, for systems that self-report.
AlphaAgents: a three-analyst desk built from one model
Role-specialized LLM agents that debate to a stock call mirror how a real research team works. The structure is the contribution. The evidence, four months and 15 tech stocks, is not yet.
XFinBench: where graduate-level finance still beats the best models
A 4,235-problem benchmark of graduate-level financial reasoning puts the best of 18 models 12.5 points behind human experts, with the gaps concentrated exactly where desk risk lives.
Memory-R1: teaching an agent when to write, update, and delete
A reinforcement-learning framework that trains an agent's memory operations from answer correctness alone, with 152 training pairs. Deletion turns out to be the skill that matters.
DeepSeek-V3.1: one model, a thinking switch
DeepSeek fused its chat and reasoning lines into a single 671B MoE with a template-level think switch under MIT. The benchmark deltas from flipping that one token are the story.
gpt-oss-120b and gpt-oss-20b: OpenAI's open weights, on your hardware
OpenAI's first open-weight models since GPT-2 put near-frontier reasoning on a single GPU under Apache 2.0. For a desk that cannot send filings or positions to an API, the build-vs-buy math just moved.
GPT-5 launches with an automatic reasoning router
OpenAI's new flagship decides for itself how hard to think on each query. For anyone budgeting cost, latency, or reproducibility around an LLM, the router is the real story.
Kronos: a foundation model for candlesticks, and the scrutiny it invites
Kronos applies the language-model recipe to market data: tokenize 12 billion candlesticks, train a decoder to predict the next one, read off forecasts. The zero-shot numbers are large. The quant's job is to ask the questions a benchmark cannot answer, about leakage, regime, and whether forecast skill survives the cost of trading on it.
GEPA: improving an agent by reading its traces, not its gradients
GEPA tunes an LLM system by reflecting on its own execution traces in plain language, proposing prompt edits, and keeping a frontier of what works. It beats a reinforcement-learning baseline by up to 20% with up to 35x fewer rollouts. For a desk with dozens of labeled examples rather than thousands, that sample efficiency is the whole game.
FinDPO: a good idea about sentiment, and a backtest to distrust
FinDPO aligns a financial sentiment model with preference optimization instead of supervised fine-tuning, and the generalization argument is sound. Then it reports a 67% annual return at Sharpe 2.0, which is where a quant should stop nodding and start checking for look-ahead and the gap between a sentiment score and tradable alpha.
Qwen3: one open model with a dial between thinking and throughput
Qwen3 ships eight Apache-2.0 models, but the feature that matters for a desk is the dial: a single model that switches between deep step-by-step reasoning and fast cheap inference. Run heavy chain-of-thought for research and drop to throughput mode for signal scoring, on weights you host yourself.
HiREC: when every 10-K looks the same to your retriever
Standardized filings are full of near-identical boilerplate, and a flat retriever happily cites the wrong company's identical-looking risk-factor paragraph. HiREC fixes it structurally: retrieve documents before passages, then curate the evidence and ask for what is missing. It is more accurate and cheaper at once.
AlphaEvolve: automated discovery, and why the evaluator is the whole game
AlphaEvolve pairs Gemini with an automated evaluator in an evolutionary loop and finds things people missed, including a 4x4 matrix-multiplication algorithm better than any since 1969. For a quant the template is automated strategy discovery, and the lesson is severe: the loop optimizes your evaluator with superhuman efficiency, leaks included.
Navigating the alpha jungle: an LLM that mines factors, and the harness it still needs
A clever framework has an LLM propose symbolic alpha formulas while Monte Carlo Tree Search refines them against backtests. The method is real. The harder half it leaves to the reader is the one a factor platform lives by: deflating for the thousands of formulas tried, and testing whether any of them survive out of sample.
Uncertainty heads: the confidence score an LLM never gave you
A small supervised head, bolted onto a frozen LLM and reading its attention, flags likely hallucinations far better than perplexity or output probability. For a regulated desk, that is the missing primitive: a calibrated per-claim confidence you can threshold into abstain-or-escalate before a number reaches a report.
FinSage: compliance-grade filing QA, built from unglamorous parts
FinSage answers compliance questions over messy financial filings and beats the field, and the gains come almost entirely from engineering: chunk metadata, four retrieval paths instead of one, and a reranker preference-tuned to surface the chunks a regulator cares about. The DPO reranker is the idea to steal.
DeepSeek-Prover-V2: when correctness is machine-checkable
Prover-V2 proves theorems in Lean 4 by decomposing them into subgoals and training on a reward the proof checker verifies. The template matters for any quant problem where correctness can be formally checked, not just estimated.
Can large language models trade? A simulated market, and a warning about correlation
Lopez-Lira builds a stock market populated entirely by LLM agents and finds it reproduces the textbook stylized facts of real markets, bubbles included. The result a desk should sit with is the one about correlation: shared models trade alike, and alike is how liquidity disappears.
Does RL really incentivize reasoning? A caution for the backtest
A sober study finds RL makes reasoning models better at the first try without expanding what they can ultimately solve. The quant analogy is exact: do not mistake variance reduction for alpha, in a model or in a trading agent.
MAST: multi-agent systems fail like organizations, not like models
1,642 annotated execution traces across seven frameworks produce the first failure taxonomy for multi-agent LLM systems: 14 modes in 3 clusters, with 44% of failures rooted in system design and specification rather than model capability. Finance has met every one of these failure modes before, in humans.
smolagents: when the agent's action is code
Hugging Face's smolagents is a minimal agent library whose agents write their actions as executable Python, not JSON tool calls. For quant work, where the action often is code, it is a natural and lightweight scaffold.
vLLM V1: the unglamorous economics of serving your own models
vLLM's V1 re-architecture cuts inference cost up to 1.7x with a cleaner core and prefix caching on by default. For a shop self-hosting LLMs, serving throughput is the line item that decides whether in-house pays.
Granular metric extraction from filings: traceability and verification beyond summarization
Clients want an agent that reads the 10-K and returns the number. Extraction, not summarization, is the hard part, and benchmarks say models fail it more than half the time. The build guide for doing it with a source on every figure and a verification gate.
FinRL-DeepSeek: an LLM news signal wired into a risk-aware RL agent
A reproducible, open template that turns financial news into an LLM signal and feeds it to a CVaR-aware reinforcement-learning allocator. The hybrid every discretionary-plus-systematic desk sketches, with the code attached.
GPT as a sell-side analyst: where it beats the human, and where it folds
A sober read on the 'AI replaces analysts' headline. An LLM reads an earnings release like an analyst but reasons through the numbers unevenly, and the useful finding is a diagnostic for when to trust its forecast.
Native Sparse Attention: cheaper long context, trained in from the start
NSA makes long-context attention fast by building sparsity into training rather than pruning it in afterward. Up to 11.6x faster at 64k while beating full attention, and why that is the enabling layer for document-heavy finance.
Kimi k1.5: the second proof that RL makes reasoning
Around the same time as DeepSeek-R1, Moonshot's Kimi k1.5 reached o1-level reasoning with reinforcement learning by a different route. Two independent recipes in one month make the technique a method, not a fluke.
The transformer enters the SDF: complexity wins asset pricing
Kelly and coauthors implant a transformer in the stochastic discount factor and report an out-of-sample Sharpe of 4.57 against 1.77 for the best classical factor model, on sixty years of US stocks. The companion theory says why: in pricing, more factors keep winning.
s1: buying reasoning with a budget you control
s1 fine-tunes an open 32B model on 1,000 examples and adds budget forcing, a dial that makes it think longer by appending 'Wait'. Why a controllable, auditable inference-compute knob matters to a quant.
DeepSeek-R1: frontier reasoning goes open
R1 matches OpenAI's o1 on hard math and code, ships openly, and distills into small models you can host. Why the distillation result, not the benchmark parity, is what changes build-vs-buy for a quant desk.
Agentic RAG: when retrieval learns to loop
Agentic RAG replaces one-shot retrieve-then-generate with a loop that plans, retrieves, critiques, and iterates. A map of the patterns, and a blueprint for a research assistant that can catch its own bad retrieval.
RAG for financial documents: a field guide
Grounding an LLM in your own filings is hard because retrieval, not the model, is the bottleneck. The proven moves that fix it, each with the evidence attached, and the discipline that makes the result safe to use.
OpenAI o1: paying for intelligence at inference time
o1 shifts the expensive part of reasoning from training to inference, thinking in hidden tokens before it answers. Where deliberate, costly reasoning pays for a research desk, and where it just burns tokens.
LOBDIF: diffusion models reach the order book
LOBDIF applies a diffusion model to the limit order book, denoising the next event's timing and type from noise. A genuine frontier-ML crossover, and a critical look at whether it beats the point processes it wants to replace.
Model Context Protocol: the integration layer finally gets a standard
Anthropic's MCP is an open protocol that lets any model reach any data source or tool through one interface. Why a standard, modeled on LSP, is what a quant platform's integration layer has been missing.
Tülu 3: an open recipe for post-training your own model
Tülu 3 releases the full post-training stack, data, code, recipes, and RLVR, on Llama 3.1. Why a reproducible recipe for training on verifiable rewards matters for a quant's own checkable tasks.
Transformer covariance for ETFs: the right target, the missing evidence
A working paper forecasts semi-covariance with transformers for downside-aware ETF allocation. The idea hits the real weak link in mean-variance. The evidence is one month long, with no costs, no turnover, and no shrinkage baseline.
Why generic embeddings cap your financial RAG
Finance-tuned BAM embeddings hit Recall@1 of 62.8% against 39.2% for the best general model, and lift FinanceBench accuracy by 8%. The retrieval ceiling is the embedding model nobody swaps.
OLMo 2: the open model a risk committee can actually audit
OLMo 2 releases not just weights but the training data, code, checkpoints, and eval harness. Why that full transparency is the ingredient model-risk governance has been missing.
QwQ-32B: frontier-style reasoning you can self-host
QwQ-32B-Preview is a 32B Apache-2.0 reasoning model scoring 90.6% on MATH-500. Why a self-hostable reasoner changes what a compliance-bound quant team can run on its own data.
FrontierMath: the math benchmark that is not saturated, and what that tells a quant
Frontier models near-perfect GSM8K and MATH, yet solve under 2% of FrontierMath's research-level problems. A sober gauge of how far to trust an LLM on a hard derivation.
LightRAG: graph retrieval that updates without a teardown
LightRAG keeps GraphRAG's cross-document reach but updates incrementally and retrieves for a fraction of the cost. Why incremental graph updates fit the constantly-arriving corpora a desk actually has.
OpenAI Swarm: a teaching toy with a lesson worth stealing
Swarm is an experimental, MIT-licensed framework built on two primitives, agents and handoffs. It is not for production. The handoff pattern, though, is the right mental model for a research-agent stack.
Contextual Retrieval: fixing the chunk that forgot where it came from
Anthropic's Contextual Retrieval prepends document-aware context to each chunk before indexing, cutting retrieval failures by up to 67%. Why it targets the exact failure that breaks RAG on filings.
RAG vs long-context: the routing trick that keeps the accuracy and cuts the bill
A Google study finds long-context LLMs beat RAG on accuracy. Its Self-Route hybrid matches long-context quality at 39-65% lower cost by sending only the hard queries to the full context.
GraphRAG: the retrieval that answers the question flat RAG cannot
Microsoft's GraphRAG builds a knowledge graph from a corpus and summarizes its communities, winning ~70-80% against naive RAG on whole-corpus questions. Why graph structure surfaces links vector search misses.
The LLM-trading-agent survey: a skeptic's reading of the backtests
A survey of LLM trading agents catalogs 15-30% returns and the shaky evaluations behind them. The median backtest runs 1.3 years, rarely counts costs, and never mentions survivorship bias.
LLMFactor: named factors from news, and the backtest that complicates them
LLMFactor extracts human-readable factors from financial news to predict stock moves. The readable factors are the real contribution; the accuracy is modest and beats baselines only half the time.
Structured Outputs: the unglamorous feature that makes LLM extraction safe to ship
OpenAI's Structured Outputs constrains generation to your JSON Schema with full adherence. Why a guarantee about shape, not a benchmark score, is what turns extraction into a system.
Mistral Large 2: the mid-sized model built for the batch job
At 123B, Mistral Large 2 lands near frontier quality at a fraction of the size. Why that efficiency, not peak capability, is what a cost- and latency-bound document pipeline wants.
FinanceBench: can RAG actually answer questions about a 10-K?
On FinanceBench, GPT-4-Turbo with a vector store got 81% of filing questions wrong or refused, while the same model with the right pages scored 85%. The bottleneck is retrieval, not the model.
RAGBench: component metrics that give a RAG answer an audit trail
RAGBench scores RAG systems on four explainable axes, and a small finetuned model beats an LLM judge at catching hallucinations. Why component-level metrics are what a regulated desk needs.
Llama 3.1 405B: a frontier model you can run behind your own firewall
Meta's 405B is the first openly available model that matches the closed frontier on knowledge, math, and code. Why that changes the build-vs-buy math for a quant desk that cannot send data to an API.
LongRAG: bigger retrieval units, fewer detached numbers
LongRAG retrieves 4K-token units instead of short passages, easing the retriever and lifting answer recall. Why coarser chunks matter for numbers buried in financial filings.
Qwen2: the open model worth self-hosting for non-English filings
Qwen2 ships five sizes up to 72B with strong math, code, and multilingual scores. Why its Chinese and Asian-language strength makes it a practical engine for a quant desk.
tau-bench: the agent reliability metric a desk cannot ignore
Sierra's tau-bench shows top agents solve a task once and then fail it on a rerun. Why pass^k is the number that decides whether an agent is safe anywhere near money.
Mixture of Agents: when a committee of open models beats one big one
An all-open-source Mixture-of-Agents stack outscored GPT-4o on AlpacaEval 2.0 with no new training. Why that is an ensembling result, what the paper's ablations prove, and where the analogy breaks.
Kolmogorov-Arnold Networks for time series: a volatility model a risk committee can read
On real implied-volatility data, T-KAN matches an LSTM with about sixty times fewer parameters and stays interpretable. The result, the architecture, and where the story gets oversold.
// Stay close to the work
Building AI that ships?
If you’re past the demo and into production, I’d love to compare notes.