The Knowledge Discovery and Data Mining Cup offers lessons for building dependable data analytics agents.
KGMON placed second in KDD Cup 2026 using a compact, inspectable harness with unified SQL access, narrow tools, schema scouting, and evaluation loops.
Key Takeaways
- NVIDIA KGMON placed second in the KDD Cup 2026 Data Agents competition by improving the agent harness around a fixed small model, not by making the model itself more complex.
- The team constrained the agent’s action space through unified data access, a narrow tool set, and a single answer-output path to reduce failures and wasted turns.
- Schema scouting before reasoning helped the agent understand tables, columns, join keys, units, and row-grain issues, reducing errors from wrong queries or misinterpreted data.
- Documents and videos were handled with preprocessing and separate extraction tools, keeping large raw content out of the main agent context and improving reliability.
- Execution traces, repeated attempts, and answer selection were used to identify failure patterns and improve performance, though ensembling was noted as costly for production systems.
Meta description: NVIDIA KGMON placed second in KDD Cup 2026 Data Agents competition by building a smaller, clearer, more verifiable agent harness around one fixed model.
Tags: Data agents, LLM harness, KDD Cup 2026, NVIDIA KGMON, analytics agents
Featured image: An abstract, friendly illustration showing a compact agent harness: a central model connected to SQL tables, documents, video frames, traces, and evaluation loops; no logos, no text, no people.
The NVIDIA KGMON team placed second in the KDD Cup 2026 Data Agents competition, and the result is most useful for developers building data science agents that must answer questions from messy, mixed data sources. Instead of trying to make the model do more, the team made the agent’s harness compact, transparent, and easier to check.
Why the harness became the main lever
The competition asked agents to answer natural-language questions across databases, CSV and JSON files, prose documents, PDFs, and briefing videos. Each task required more than search: the agent had to inspect available data, choose tools, reason across sources, create a final answer file, and avoid traps that appear in analytical workflows.
KDD also required teams to use a small fixed large language model, which shifted optimization to the surrounding harness. The KGMON team tried to make the task easier for that model through preprocessing, constrained tools, persistent state, and evaluation. Those methods may also help when building reliable systems around smaller open models.
Two rules shaped the agent
The first rule was to constrain the action space. The team reasoned that too many ways to inspect data, call tools, write files, or recover from errors create failure points. KGMON unified data access, exposed a narrow tool set, and required answers to go through one output path.
The second rule was to make every attempt inspectable. A failed run could come from a bad tool call, wrong join, missed document rule, or output-format issue. Execution traces, repeated attempts, and trajectory inspection let the team find failure patterns and adjust the harness.
Unified data access, schema context, and a narrow tool set
Each task could mix SQL databases with CSV and JSON files. KGMON converted those files into tables inside the existing SQLite database, so the agent had one SQL interface for structured data. Its persistent Python environment exposed two built-in functions for inspecting and querying that unified surface. The result reduced routing errors and wasted turns, giving the fixed model more room to reason.
Before the main reasoning loop, the team added schema scouting. The system inspected tables, columns, possible join keys, duplicate names, similar-looking fields, units, null patterns, and row-grain issues. The agent received that context at the start of each task, saving an early discovery turn. This reduced errors caused by wrong columns, missed joins, or confusion about what each answer row represented.
The tool harness stayed small and opinionated. Helpers covered schema inspection, SQL queries, document lookup, prose extraction, and answer writing. Middleware repaired malformed tool calls so one bad call did not end an attempt. The stateful Python environment kept variables between calls, letting the agent reuse intermediate results. Predefined functions such as schema(), sql(query), and write_answer(df) reduced boilerplate, syntax errors, and file-handling mistakes. Short, valid attempts left more turns for additional runs, evaluation, and ensembling, which combines results from multiple attempts.
Documents, videos, traces, and improvement loops
Prose sources were treated as first-class inputs, but kept separate from structured data. In some tasks, PDFs, Markdown files, policy text, instructions, and reports contained thresholds, rules, definitions, and table-like records. Because large documents can consume a model’s context window, KGMON blocked direct reads through Python’s open() function or .read() method. It provided tools that limited previews and searches by character count or regular expression matches.
After finding a relevant section, the agent could call prose_helper, a custom tool that passed document chunks to a separate LLM call with temperature set to 0 and reasoning disabled. It returned answers or extracted tables, keeping raw document text out of the main agent’s context. The team noted that table extraction suited competition tasks where structured information was embedded in documents, while production systems may need only targeted prose lookup.
Some tasks included briefing videos, with at most one video per task. To avoid processing video inside the agent loop, KGMON extracted keyframes, transcribed audio, aligned transcript segments with frames, and supplied that evidence to the agent. This connected spoken context to the right visual evidence. For larger video collections, an on-demand helper may be a better fit.
Every attempt was logged. Prompts, tool calls, SQL queries, intermediate results, errors, repairs, document lookups, and final answers were recorded. A specialized inspector agent could review failed trajectories, categorize mistakes, and surface recurring failures. The traces showed whether a wrong answer came from schema confusion, an incorrect join, missed prose evidence, output formatting, or a brittle prompt rule.
KGMON also used repeated attempts and answer selection to improve coverage. It grouped attempts by answer values rather than column names and gave contested tasks additional runs. This helped separate stable answers from one-off mistakes under the leaderboard’s exact value-level scoring. The team noted that repeated attempts increase token usage, latency, and compute cost, so production systems should reserve ensembling for tasks where the value, uncertainty, or risk justifies the expense.
Autonomous improvement loops can refine prompts, tools, postprocessing, and evaluation logic, but they can also overfit to a benchmark. KGMON saw risks such as hardcoding training examples into prompts, accumulating contradictory instructions, adding brittle postprocessing rules, and improving one benchmark split while hurting generalization. The team required held-out tasks, prompt audits, trace review, and human approval before promoting changes. People defined task requirements, audited traces, guided early agent behavior, rejected brittle changes, and selected improvements to keep. That targeted human review improved future runs without needing oversight of every tool call.
What builders can copy and what to leave behind
The exact KDD solution was shaped by the benchmark: a fixed model, no internet access, heterogeneous task bundles, value-level scoring, and a long-run budget. Not every design choice should move directly into production. The transferable practices are more general: normalize structured-data access before the agent begins; give the agent a small, reliable tool surface; make every attempt traceable; evaluate both answers and trajectories; use repeated attempts only when the cost is justified; preserve reusable knowledge; and validate improvements before promoting them.
For a first project, start with one repeatable analytics workflow and build the smallest harness that can complete it. Define the question and required answer format. Give the agent a narrow set of tools for inspecting and querying data. Record every tool call and intermediate result. The KGMON result points to a practical lesson: reliability depends less on expanding the model’s freedom and more on shaping a clear, safe path for it.

Comments (0)