projects | Dean Light

Deep Reasoning — steering the reasoning of LLM agents

Top-down. Instead of hard-coding an agent’s reasoning structure up front, I want agents that build just-in-time scaffolds mimicking dynamic meta-reasoning — constructing the reasoning structure each task actually needs at inference time. Done right, this makes an agent’s reasoning something a human can inspect and control, rather than a fixed black-box pipeline.

Deep Reasoning in General Purpose Agents via Structured Meta-Cognition

arXiv:2605.11388 · 2026

Current LLM agents hard-code their reasoning scaffold in advance — effective when the prescribed structure matches the task, brittle when the task needs a different shape of reasoning. Deep Reasoning introduces a formal language that represents meta-reasoning as executable decompositions over associative inference, formal computation, and recursive subproblem solving, so scaffolds are constructed just-in-time from in-context examples. Instantiated in a general-purpose agent, DOLORES, it distributes a task across more controlled, lower-load reasoning threads — beating the strongest evaluated scaffold by 24.8% on average across multi-hop reasoning, long-chain QA, long-context aggregation, and deep-research information seeking, with an 8B model surpassing 32B baselines in more than half the settings. This is the core of the top-down direction: reasoning structure as something built and inspected, not baked in.

RelaNN — learning over structured representations

Bottom-up. How can we learn over structured data without throwing the structure away? I want a world where writing a structured neural network over a database is about as easy as writing a query — so domain-experts can build structured deeplearning models using their domain expertise.

Incorporating Deep Learning Design in Database Queries

arXiv:2605.24207 · 2026

Deep learning over relational databases is conventionally realized by translating data into graph representations and applying graphbased neural networks within external frameworks . This round-trip between the database and external machine learning (ML) systems introduces non-trivial engineering overhead. In effect, these graph neural networks operate on tuple embeddings and manipulate them in ways that capture the interactions induced by relational joins. Given this natural correspondence, there is no fundamental reason why specifying a neural network over relational data should be substantially harder than querying it. We propose an approach that naturally integrates deep learning with database queries. The key idea is to associate each tuple with provenance, represented as a vector embedding with learnable parameters. Queries are lifted to operate jointly on data and embeddings, mapping input relations with embedded tuples to output relations with embedded tuples. This approach provides a declarative foundation for relational deep learning, facilitating integration with database systems, optimization, and wide adoption. We describe RelaNN, a proof-of-concept implementation of this approach built on top of PyTorch and cuDF. We illustrate the utility of RelaNN by implementing various graph-learning models, including graph convolutional networks, heterogeneous graph transformers, hypergraph neural networks and deep homomorphism networks. The simplicity of the programs and their competitive runtime performance demonstrate a concrete path toward making the implementation of state-of-the-art neural networks over databases as simple as writing a query.

SpannerLib: Embedding Declarative Information Extraction in an Imperative Workflow

VLDB 2024 · arXiv:2409.01736

An earlier step in the language embedding strategy RelaNN uses. Document spanners are a formal framework for declarative information extraction from text; SpannerLib embeds them in imperative Python by implementing Spannerlog (Datalog-based document spanners) that interoperates in both directions — rules can be embedded inside Python, and rules can invoke custom Python (e.g., ML-based NLP models) through user-defined functions. It shows how declarative structure over messy, real-world data can compose cleanly with imperative and learned components — the compositionality that RelaNN then extends from extraction to learning.