Artificial intelligence tools have rapidly become indispensable co-pilots for corporate data teams, promising to slash the time required to wrangle complex datasets, write code, and surface actionable insights. Yet, a recent empirical experiment testing advanced AI models on routine business queries reveals a sobering reality: while automated systems excel at syntax and execution, they remain highly vulnerable to subtle analytical failures that standard code checks will never catch.
Conducted using OpenAI’s high-performance models alongside standard data manipulation libraries like Pandas and SciPy, the experiment simulated a typical week of business inquiries across three distinct datasets. The tasks ranged from calculating average delivery times and identifying top-performing sales regions to tracking athlete metrics in historical Olympic files.
The findings demonstrate that while automated data analysis pipelines can produce clean, syntactically correct code, they frequently stumble over the unstated context of the business problem. Furthermore, when these models are asked to review their own work in a simulated executive verification pass, they often fail to correct fundamental errors—and in some cases, actively invent new mistakes while applying a false sense of security.
The Testing Ground and Initial Discrepancies
To evaluate how artificial intelligence handles everyday data tasks, researchers fed three datasets into GPT-5.6 Terra for rapid initial processing and GPT-5.6 Luna for deeper, unhurried analysis. The first file, shipment_tracking, contained forty rows of order data complete with timestamps for order placement, warehouse shipment, and final delivery. The second file, regional_sales, captured multi-year sales figures across various global regions, while the third file, olympics_athletes_events, detailed individual athlete participation across multiple Olympic Games.
The first major error emerged during a routine request to find the average delivery time for the shipment tracking dataset. The model generated a clean Pandas script that subtracted the shipping date from the delivery date, yielding an average of 2.6 days. While the code executed perfectly without throwing any exceptions, it answered the wrong question.
From a customer’s perspective, delivery time begins the moment an order is placed at checkout, not when it finally leaves the warehouse. When calculated correctly from the order date to the delivery date, the actual average duration rose to 6.09 days—more than twice the AI-generated figure. Because the code was technically valid and executed without error, traditional debugging tools and type checks failed to flag the discrepancy. The mistake lived entirely within the selection of columns, proving that no automated script can substitute for understanding what a metric actually means to the end user.
Fabricated Figures and Ghost Code
Another recurring issue involved the appearance of numerical values that were never computed by any underlying code. In multiple instances across different datasets, the models presented executive summaries containing figures that bore no relation to the code blocks displayed alongside them.
For the shipment_tracking dataset, an AI-generated summary correctly noted that twenty-two out of forty orders had recorded delivery dates, but then appended a warning stating that only twenty-two of fifty orders had delivery dates, leaving twenty-eight still in transit. The numbers fifty and twenty-eight appeared nowhere in the execution logs. Because the fabricated numbers were mathematically consistent—fifty minus twenty-two equals twenty-eight—an executive reading the text quickly would find no obvious internal contradiction.
A similar hallucination plagued the regional_sales dataset analysis. Asked to identify the top-performing region, the model pointed to APAC, citing astronomical sales figures and specific percentage shares that vastly inflated the region’s actual revenue. An examination of the session logs revealed a troubling pattern: the model had presented a polished narrative complete with fabricated statistics without ever executing the underlying code.
Even when code execution was enforced, models occasionally drifted into fabrication. In a separate run, an unhurried model accurately executed its queries but still incorrectly claimed that one region was significantly ahead of two others combined, despite the actual underlying sums proving the statement mathematically false. This disconnect highlights a critical vulnerability in AI-driven reporting: the numbers inside a code block are computed, but the numbers in the surrounding prose are written by language generation, and nothing forces the two to agree.
Misinterpreting Trends in Incomplete Data
Temporal data proved particularly treacherous for the AI models, especially when dealing with censored data—information where certain events have not yet occurred because the observation window has closed. When asked whether shipping times were improving or worsening over a three-week period, the fast-pass model concluded that operations were accelerating, citing a drop in average delivery days from 3.17 in week one to just one day in week three.
The numbers were technically accurate for the rows examined, but the conclusion was entirely backwards. The dataset concluded abruptly on January 21, meaning orders placed in the third week had only a few days to reach their destination, whereas week-one orders had enjoyed a full window of observation. Furthermore, seventy percent of week-three orders lacked delivery dates simply because they were still in transit. The slower orders had not yet arrived to be measured, creating the illusion of rapid processing efficiency simply because more of the recent evidence was missing.
Interestingly, when given the same dataset without time pressure, the Luna model caught this trap unprompted, issuing a cautionary note that the apparent performance improvement was an artifact of incomplete data. This divergence underscores the risk of relying on rapid AI generation for trend analysis without accounting for the boundaries of the data collection window.
The Blind Spot of Missing Values
Data hygiene issues also led the models astray, particularly regarding missing values. When analyzing the olympics_athletes_events dataset to determine whether physical height influences an athlete’s likelihood of winning a medal, the fast-pass model compared the average heights of medalists and non-medalists, concluding that height barely mattered due to a negligible difference of just three millimeters.
While the arithmetic was correct, the underlying Pandas operations automatically dropped every row containing a blank height value without notifying the user. Consequently, the analysis quietly discarded nearly two-thirds of the dataset, executing on a fraction of the total records. Further investigation revealed that the presence of a recorded height was not random; it strongly correlated with more recent Olympic Games, where medal rates were significantly higher. The model had inadvertently analyzed a heavily skewed subset of the data while remaining entirely oblivious to the mass deletion of rows performed silently by the software library.
The Limits of Self-Correction
To test whether artificial intelligence could reliably audit its own work, researchers initiated clean sessions, fed the original flawed summaries back into the models, and instructed them to verify every figure for an executive presentation. The results were mixed and, in some cases, counterproductive.
During the verification of the shipment_tracking analysis, the review pass successfully caught and corrected the fabricated total order count, fixing the discrepancy regarding undelivered items. However, it explicitly approved the flawed delivery time metric that answered the wrong question, as well as the misleading trend analysis driven by incomplete temporal data. Armed with the correct underlying counts, the model still failed to connect the dots between the unarrived orders and the false acceleration trend.
The review of the Olympics dataset went further off track. While the model correctly identified a grain-level error regarding individual records versus unique athletes, it completely missed the massive omission of blank height values. Instead, it invented a new set of average heights through an incompatible grouping of data, labeled the original calculation a major error, and reversed its conclusion to claim a strong correlation between height and winning—a claim entirely unsupported by the usable subset of the data.
Ultimately, the experiment demonstrates that while modern AI models excel at generating functional syntax and parsing structured data, they stumble when critical answers depend on context that lies outside the dataset itself. Unstated business definitions, unexecuted code prose, censored temporal windows, and silently dropped missing values all represent blind spots that automated reasoning cannot reliably navigate on its own. While artificial intelligence remains a powerful tool for accelerating data preparation and arithmetic verification, human oversight remains essential for ensuring that the numbers actually mean what the narrative claims they do.
