Sigma AI Labs: A recap of our summer 2026 intern program
This summer, Sigma’s AI Labs team welcomed a cohort of elite PhD researchers to tackle the next frontier of intelligent data systems. Together, these projects move Sigma AI toward systems that learn from experience, reason more reliably over ambiguous questions, and deliver trustworthy answers faster and at lower cost. Across various benchmarks, their work improved accuracy by up to 10 points, matched state-of-the-art results at up to 100x the speed end-to-end, and cut costs by as much as 10x. For Sigma customers, that means an assistant that grows more fluent in their business over time and takes on harder analytical work, from generating ML-based predictions to open-ended research.
Before their time at Sigma came to a close, we asked each intern to write about their summer project. Read on to see their reflections and learn how these four innovators helped shape the future of AI at Sigma.
If you are a PhD student and find these projects as exciting as we do, consider joining us next summer in San Francisco or New York!
Architecture for Long-Term Memory
By William Sun, PhD candidate at University of Wisconsin-Madison
Real customer questions arrive underspecified, with ambiguous goals, missing definitions, and business logic left implicit. Across sessions, a stateless agent must recover all of it the hard way, over rounds of reasoning, tool calls, and clarification, each one appending tokens where signal and noise compete for the same attention. The waste is that this work is rarely novel. Definitions recur, database structures repeat, and solutions look alike, but without memory an agent starts each task as if it were its first. My project asked how agentic systems can learn across tasks in the most efficient way possible.
The resulting system gives the agent a task-oriented memory. After each task, the agent observes its own trace of reasoning, actions, SQL, and corrections, processes it, then distills findings into a reusable record. Specificity is what makes a record worth retrieving. The strongest ones carry correct SQL queries, exact business definitions, or the specific failure that motivated a correction. Abstracted strategies can generalize past the point of usefulness and tend to distract more than they steer. Modern LLMs are good at authoring these records themselves, and in our experiments’ agent-authored memories outperformed externally imposed templates and hand-designed abstraction schemas. At inference time, a retrieval pipeline scores the store against the incoming request and injects the top matches into the agent's context.
Evaluation design carried as much weight as the system itself. We evaluate our memory system using three structured data benchmarks: ARCHER, BIRD-INTERACT (c-Interact), and Sigma's internal benchmark. Evaluation runs under two operating modes. The first is online memory where the store grows as evaluation proceeds (must account for order dependency). To avoid measuring from a cold store, we synthesize a training set offline and have the agent generate memories as it works through the set. In the second, we use hold-one-out evaluation. Each task has its own independently generated memory, but when a task is evaluated, its own memory is withheld and only memories from the other tasks are available for retrieval, so order has no effect.
Across all three benchmarks, adding memory improves execution accuracy over the same agentic system without memory by 5-10 points, a 10-30% relative gain. When constrained to fewer turns, the memory-augmented agent cuts latency by half while retaining 90% of the performance of a no-memory agent allowed to run longer. Memory also lets lightweight models such as GLM-4.7 and GPT-5.4 nano match or exceed a larger no-memory model, GPT-5.4, at roughly one-third lower cost.
More broadly, this work moves the unit of intelligence from a single model response to a system that compounds across a sequence of tasks. Memory does not replace reasoning or interaction: It gives both a better starting point. For Sigma customers, that could mean an assistant that grows fluent in the metrics, vocabulary, and analytical patterns of their business, delivering answers more consistently, more quickly, and at lower cost as the store fills.
Revolutionizing Tabular ML
By Howard Prioleau, PhD candidate at Howard University
Language models reason over data impressively well, but they cannot produce a trustworthy probability by inspection. Ask one to estimate the odds that an account churns and you get a confident-sounding number with no calibration behind it. A model fit to your labeled outcomes gives you calibration, and fitting one is the easy part. The hard part is turning a vague business question into a well-posed target, cohort, and feature set in a real enterprise database. This project teaches an agent to handle that framing itself, so it can reach for a real model the way an analyst reaches for a SQL query. That is TabularML. It takes a natural language query framed as a classification or forecasting task and returns a calibrated prediction, opening a new axis for asking questions of your data on the Sigma platform. Those questions span hypotheticals (“What would we predict for churn on a new enterprise account?”), forecasts (“Where is this account's revenue headed next quarter?”), and more.
No existing benchmark captures the intersection of natural language query understanding and predictive modeling over databases, so we started from RelBench, a public benchmark for predictive tasks over real-world relational databases and augmented it to fit our needs. RelBench supplies the databases along with predefined entity, target, and split definitions, and we augmented them with a natural language question layer to reflect user requests that would require predictive ability. The result gives us a standardized way to measure prediction quality across classification and regression tasks.
On our benchmark, TabularML reaches about 93% of state-of-the-art performance on Relbench with no natural language question while running roughly 100x faster end-to-end, because it skips the per-task GPU fine-tuning that stronger methods require. The tradeoff TabularML makes unlocks a highly interactive experience, closing the loop between asking a question and getting a calibrated answer in seconds rather than hours. This approach also handles any dataset size, selecting a representative subset that preserves near full-dataset performance rather than processing every row.
TabularML represents an exciting new axis of analysis: the ability to turn a natural language question into a calibrated, trustworthy prediction over your own data, with the reasoning behind that prediction fully inspectable rather than hidden inside a black box. Where other systems query the rows you have, this one infers the rows that aren't there yet.
The Evolution of Autonomous Planners
By Alina Gorbunova, PhD candidate at Georgia Institute of Technology
In a common agentic design, the planner breaks a user's question into subtasks, selects the tools for each, and routes the right inputs to every call. Whatever the design, a planner will encounter a variety of tasks that have some fundamental similarities in how to solve them. Allowing the planner to learn these over time to more quickly and accurately solve unseen problems is key to adapting to users.
One way for an agent to encode learned processes for reuse is to build skills, each one packaging a recurring tool sequence with guidance on when to invoke it. The planner induces its skills by having an LLM reflect over past traces. These learned skills are exposed to the planner alongside its base tools, so it can emit a single skill invocation in place of deriving the underlying sequence of tools.
| Mean Reward ↑ | Cost per Task ↓ | Median Time per Task ↓ | |
|---|---|---|---|
| No Skills Planner | 28.0% | $0.35 | 50.6s |
| Planner with Learned Skills | 31.5% | $0.34 | 37.3s |
| Planner with Learned Skills and an Example | 35.3% | $0.36 | 42.0s |
Results of skills learned from 60 BIRD-Interact a–interact mini questions, validated on 100 BIRD-Interact a–interact mini questions, and evaluated on 300-question BIRD-Interact a–interact lite questions, with GPT 5.4.
We evaluate the pipeline on BIRD-Interact, a text-to-SQL benchmark built to mimic the underspecified, multi-turn questions real users ask. Learned skills lift performance 3.5%. Adding one worked example takes it to 7.3%, so the example augments the skills it demonstrates. Cost stays flat, latency drops.
Further analysis of generated skills show that revisement skills, which fire after a rejected answer, had the most impact. Failure is the modal outcome on underspecified queries, so one aspect that separates good planners from poor is not how well they can adapt to rejection. Encouraging the agent to add trace-mined examples also furthered the gain.
No engineer wrote these skills. The planner mined them from its own execution history and kept only what survived a held-out test, which is exactly the mechanism a static design lacks. When users, models, and tools shift, this planner has a way to shift with them.
Extracting Insights from Complexity
By Leon Tran, PhD candidate at University of Washington
Deep research is a mode of operation where an agent must tackle an open-ended question, gathering evidence and synthesizing an answer. It is one of the harder agentic problems. There is no verifiable target to check a step against, and each move depends on what the previous one revealed. An analyst resolving an open-ended business inquiry runs exploratory data analysis, a loop of proposing narrow questions against the data, reading the answers, and re-proposing based on what surfaced. The loop continues until latent structure becomes legible enough to recommend action on. Modern structured datasets span millions of records across dozens of dimensions, so the hypothesis space that loop searches grows faster than any analyst can traverse it. A deep research system can automate that search.
Most existing systems converge on the same propose-execute-synthesize decomposition, so we scope our analysis to that class. Ours runs three agents over a shared graph, one proposing hypotheses, one retrieving structured and unstructured evidence from a large corpus, and one synthesizing the results into a report. The graph serves as the system's evolving working memory, constructed dynamically at runtime rather than relying on a pre-existing knowledge graph. Nodes represent concepts found in the data, while edges encode evidence-backed relationships between them. For example, a finding that customer satisfaction correlates with product price at -0.5 would be represented as two nodes connected by a signed, weighted edge. As agents explore the data, they continuously expand and refine this graph, preserving accumulated findings and guiding subsequent inquiry toward unexplored relationships and knowledge gaps.
Every stage reads that structure. Hypothesis generation orders goal-relevant nodes by degree and expands into low-degree pairs first, steering the search toward regions the graph has yet to cover. Flat representations, a set of prior questions or summaries of executed SQL, carry no such signal, and we find the graph scales considerably better with test-time computation.
We evaluate on two public deep research benchmarks over enterprise corpora (DRBench, InsightsBench) with planted ground truth. The metric is grounded insight-level recall: an LLM judge only credits an insight if its statistics and citations trace back to the corpus, so ungrounded output scores zero. Against closed-source systems, we improve recall by 11% over the next best system at comparable latency and roughly 10× lower cost.
Much of the savings comes from replacing long-horizon reasoning in models like OpenAI-o3 with lighter models guided by the concept graph, which shows each agent what has been learned and what remains unexplored. Extra test-time compute goes toward new parts of the hypothesis space instead of reconstructing prior reasoning, which suggests structured state can substitute for some model-scale reasoning. For Sigma users, that could mean handing off an open-ended question, like “Why did churn rise last quarter?” and getting back grounded, cited findings. Those findings would cover more ground than any analyst could search, at a cost low enough to use every day.
Looking Ahead
Each of these projects took on a hard, open problem at the center of our research agenda. Working alongside the AI Labs team, the interns turned those problems into systems that learn from experience, reason under ambiguity, and deliver answers users can trust. Their results sharpen the direction of our work and bring us closer to AI that goes beyond answering questions to getting important work done. We're grateful to William, Howard, Alina, and Leon for a remarkable summer.
Interested in joining our next cohort? We’re hiring summer 2027 AI Labs interns! Apply to our San Francisco or New York City programs.
