The NVIDIA KGMON team finished second in the KDD Cup 2026 Data Agents competition with a system built around a simple principle: make the agent’s harness smaller, clearer, and easier to verify. The competition required agents to answer natural-language questions over heterogeneous data sources — including SQL databases, CSV and JSON files, prose documents, PDFs and briefing videos — and every task demanded more than retrieval. Agents had to inspect available data, choose appropriate tools, reason across sources, produce a final answer file, and handle traps common in analytical workflows.
A key constraint of the benchmark was that teams had to use a small, fixed large language model (LLM) to power the agent, which made the harness the primary optimization surface. KGMON focused on making the task easier for that model through preprocessing, a constrained toolset, persistent state, and careful evaluation. These techniques are particularly relevant when building reliable systems around smaller open models.
Two guiding principles
Two core principles guided the design:
- Constrain the action space. Too many ways to inspect data, call tools, write files, or recover from mistakes increase failure modes. KGMON unified data access, exposed a small set of tools, and required final answers to follow a single output path.
- Make every attempt inspectable. Runs can fail for many reasons — bad tool calls, incorrect joins, missed document rules, or formatting issues. Execution traces, repeated attempts, and trajectory inspection helped the team find failures and refine the harness.
The team’s playbook is not a universal recipe for every data science agent, but the broader lesson is widely applicable: reliability often comes more from the right harness than from making the model more open-ended.
Practical techniques used by KGMON
- Convert structured sources into one query surface
KGMON converted CSV and JSON files into tables in an existing SQLite database so the agent had one SQL interface for all structured data. Their persistent Python environment exposed two built-in functions for inspecting and querying that unified surface: schema() and sql(query). These functions reduced routing failures and wasted turns, leaving the fixed model more room to reason.
Apply: normalize access to structured data before the agent runs — via a temporary SQLite, a virtualized query layer, or a governed warehouse interface.
- Seed the agent with schema context up front
They added a schema-scouting step before the main reasoning loop: inspecting tables, columns, possible join keys, duplicate names, look-alike fields, units, null patterns, and row-grain issues. The agent received that schema context at the start of each task, saving an early discovery turn and reducing errors from wrong columns or missed joins.
Apply: include a read-only preflight that briefs the agent on available tables, likely joins, key columns, suspicious fields, and known ambiguities.
- Build a small, opinionated tool harness
KGMON limited the agent to a handful of helpers for schema inspection, SQL queries, document lookup, prose extraction, and answer writing. The exposed functions included schema(), sql(query), write_answer(df), and prose_helper(). Middleware repaired malformed tool calls so a single bad call did not end an attempt. A stateful Python environment retained variables between calls so the agent could reuse intermediate results.
Apply: design tools around workflow requirements and remove duplicate paths. A single approved way to run SQL or write answers reduces state corruption and invalid outputs.
- Treat prose as a first-class input, but keep it separate from structured data
Documents often contained thresholds, rules, definitions, or table-like records necessary to answer questions. To avoid loading entire documents into the agent’s context window, KGMON blocked direct open()/.read() of full files and provided tools that offered limited previews and searches by character count or regex matches. After locating a relevant section, the agent could invoke prose_helper — a separate LLM call with temperature 0 and reasoning disabled — to extract answers or convert repeating records into SQL tables.
Apply: provide a document-inspection tool that answers targeted questions and cites sources without loading whole documents into the main agent context. Add table extraction only when documents contain repeated records that need joins or filters.
- Preprocess video when it is part of the task
For tasks with briefing videos, KGMON preprocessed by extracting keyframes, transcribing audio, aligning transcript segments with frames, and supplying the aligned evidence to the agent. This avoided expensive video processing inside the agent loop and connected spoken context to visual evidence.
Apply: preprocess a limited set of videos ahead of the agent loop; for larger collections, provide an on-demand helper for video inspection.
- Log traces so another agent or a human can inspect failures
Each attempt logged prompts, tool calls, SQL queries, intermediate results, errors, repairs, document lookups, and final answers. A specialized inspector agent or human reviewer could analyze failed trajectories, categorize mistakes, and prioritize harness improvements. Traces reveal whether a wrong answer stemmed from schema confusion, an incorrect join, missed prose evidence, output formatting, or a brittle prompt rule.
Apply: build trace inspection into development — a subagent or evaluation script can categorize failures and recommend harness changes.
- Evaluate multiple attempts, but watch the cost
KGMON used repeated attempts and answer selection to improve coverage and reliability. They grouped attempts by answer values and allocated extra runs for contested tasks. Multiple attempts helped distinguish stable answers from one-off mistakes under the leaderboard’s exact value-level scoring. However, repeated attempts increase token usage, latency and compute cost; use ensembling selectively in production.
Apply: start with single-run evaluation and trace inspection; use confidence, disagreement, or validation failures to decide when extra attempts are justified.
- Use improvement loops carefully
Autonomous improvement loops can refine prompts, tools, postprocessing and evaluation logic, but risk overfitting to a benchmark. The team observed risks such as hardcoding training examples into prompts, accumulating contradictory instructions, adding brittle postprocessing rules, or improving one split while hurting generalization.
Apply: require held-out tasks, prompt audits, trace review, and human approval before promoting changes.
- Keep humans in the right part of the loop
Human guidance was combined with agent-scale experimentation: people defined task requirements, audited traces, guided early agent behavior, rejected brittle changes, and selected improvements to keep in the harness. Targeted human interventions improved future runs without supervising every tool call.
Apply: let agents run and explore; let people decide which improvements are reused and which should be rejected.
Top lessons
The KGMON solution reflected the benchmark constraints (fixed model, no internet, heterogeneous tasks, value-level scoring, and budget). While not all design choices translate directly to production, the following practices generalize:
- Normalize data access before the agent starts.
- Give the agent a small, reliable tool surface.
- Make attempts traceable and evaluable.
- Use repeated attempts selectively.
- Preserve reusable knowledge and validate improvements before promotion.
Getting started
Begin with one repeatable analytics workflow and build the smallest harness that can complete it:
- Define the question and required answer format.
- Provide a narrow set of tools for inspecting and querying data.
- Record every tool call and intermediate result.
- Create a small evaluation set with both successful cases and likely failure modes.
- Review trajectories, then refine tools, prompts, and validation checks.
Once the foundation is reliable, add document inspection, shared knowledge, reviewed improvements, and selective evaluation of multiple attempts.
Conclusion
NVIDIA KGMON’s second place at KDD Cup 2026 demonstrates that with a fixed small LLM, system reliability often hinges more on the design of a small, verifiable harness than on increasing model flexibility. Unifying data access, pre-seeding schema context, limiting tools, preprocessing prose and video, logging traces and carefully managing improvements together improved robustness across the competition’s heterogeneous analytic tasks.
(The article synthesizes KGMON’s published playbook and recommendations as applied to the KDD Cup Data Agents benchmark.)
