During our latest webinar with Workday Adaptive Planning, we asked the audience a simple question: what data challenge is causing you the biggest headache right now? Fifty-five percent said the same thing. Their data lives in Excel or some other non-centralized source.
Nobody on the call was shocked. Ben Pierce, General Manager of Workday Adaptive Planning, walked through the pattern right after the results came in: a finance team needs a view their BI tool doesn't have, so they pull data out of the ERP, drop it into a spreadsheet, and spend the next several hours building VLOOKUPs and pivot tables just to get back to a starting point. Most of the effort goes into wrangling the data instead of actually analyzing it.
Analysts have been predicting Excel's decline for years. Gartner has forecast that by 2026, more than 70% of finance organizations will have moved off spreadsheets as their primary planning tool. But the Association for Finance Professionals' 2025 FP&A Benchmarking Survey tells a different story: 96% of finance practitioners still use spreadsheets weekly for planning, and 93% use them weekly for reporting, even at companies that already run a dedicated EPM platform.
Read those two data points side by side and the gap is hard to miss: trhe prediction and the reality aren't close.
And we get it! Excel is fast, familiar, and flexible in ways purpose-built systems often aren't. Nearly every finance professional already knows how to use it, so there's no training curve and no waiting on IT. When a forecast needs updating before a Monday meeting, Excel is usually the quickest way to get there.
The problem shows up later, once that spreadsheet becomes the system of record for a decision instead of a scratchpad for one.
A few things happen once Excel becomes the default workflow instead of a backup option.
Time disappears into data prep instead of analysis. The AFP numbers above aren't describing a minority workaround. They're describing how most finance teams spend most of their week, and it's rarely on the parts of the job that actually move the business forward.
Trust erodes. UK research from Sixthfin, covered by The Fintech Times, found that 67% of firms still run their financial close in Excel, and roughly a third of finance leaders admit they don't fully trust the reliability of their own close figures. When a number can't be traced back to its source with confidence, every conversation built on that number starts from a weaker position.
Errors compound quietly. Spreadsheets have no native audit trail. There's no built-in way to see who changed a formula, when, or why. A single broken link or copy-paste error can sit undetected for a full reporting cycle, and by the time it surfaces, it's already shaped a decision.
The close gets harder every month, not easier. Every one of those workarounds gets rebuilt from scratch next period. Nothing compounds in the team's favor. The same manual work just repeats.
Every attempt to force finance teams off spreadsheets by fiat runs into the same wall: Excel solves a real problem, and ripping it away without solving that problem first just pushes the workaround somewhere else.
The actual fix is giving finance direct, governed access to live operational data, so the spreadsheet stops being the only place that data can be shaped and explored. During the Incorta Builder launch webinar, this showed up directly in the forecast and planning app demo: users got an editable, grid-based planning interface that felt like Excel to work in, drag, fill, adjust assumptions, but every number underneath it was live, governed, and tied back to its source. Saving a plan wrote directly to the underlying database instead of creating another disconnected file that only one person understands.
That's the shift: not eliminating the spreadsheet experience finance teams are comfortable with, but connecting it to a foundation where the data is trustworthy, current, and traceable by default.
At Incorta's "Beyond the Close" webinar, 20% of attendees pointed to untrustworthy data as their biggest challenge, right behind the 55% stuck in Excel. Twenty percent might sound manageable next to a majority-vote problem. It isn't. It means a meaningful share of finance leaders are making decisions on numbers they don't fully believe, and saying so out loud in a room full of peers.
Mike Nader, Field CTO at Incorta, put the underlying issue plainly during the session: finance and accounting teams have to be able to communicate in a common way, and that starts with agreeing on what a number actually means. Without shared rules and shared context, two people can look at the same figure and mean two different things by it.
Data doesn't become untrustworthy on its own. It happens gradually, through a specific set of failures that show up in almost every finance function at some point.
Systems get connected by hand instead of through a governed pipeline, so every export is a fresh opportunity for something to drop or duplicate. Business rules live in someone's head, or in a spreadsheet formula nobody's touched in two years, instead of in a place the whole team can see and reference. There's no lineage, so when a number looks off, nobody can quickly trace it back to the transaction that produced it. And definitions drift. One team's "active customer" is another team's "customer with an order in the last 12 months," and nobody notices until the two reports don't match.
Any one of these is manageable. Stacked together, they're exactly why a fifth of a finance audience will say out loud that they don't trust their own numbers.
Cloudera's 2026 Data Readiness Index surveyed 1,270 IT leaders and found that while 85% believe they have a clear data strategy, only 18% consider their data fully governed. Informatica's CDO Insights 2026 study of 600 global data leaders found that 76% say their organization's AI governance can't keep pace with how employees are actually using AI day to day. And Grant Thornton's 2026 AI Impact Survey found that 78% of business executives lack confidence they could pass an independent AI governance audit within 90 days.
The same governance gap showing up in finance teams' Excel workflows is showing up across every function racing to adopt AI, and finance has more exposure than most, because nearly every decision in a company eventually shows up as a financial outcome.
Point an AI model at ungoverned, disconnected data and it won't hesitate the way a skeptical analyst would. It'll answer confidently, using whatever pattern it finds, whether or not that pattern reflects what's actually happening in the business. The output looks polished. The trust problem is just harder to see until something goes wrong.
Fixing this isn't about finding a smarter model. It's about giving finance a data foundation that's governed at the source, not cleaned up after the fact.
That means data landing exactly as it looks in the system of record, with no undocumented transformation on the way in. It means rules and business logic applied consistently, in a shared semantic layer instead of scattered across individual spreadsheets. It means every number staying traceable, so a finance user can walk from a summary figure back to the line-level transaction that produced it, in a few clicks, without filing a ticket. And it means that same foundation, and the same governance, applying whether a person is asking the question or an AI agent is.
That last point matters more every quarter. An agent answering a finance question needs to inherit the same row-level security and the same audit trail a human user would get from a dashboard. Otherwise, adding AI just adds a new, faster way to act on bad data.
Finance teams didn't lose trust in their data because they weren't paying attention. They lost it because the systems underneath weren't built to keep pace with how fast the business changes. Closing that gap takes a foundation that's governed from the moment data lands, not a faster way to query whatever's already there.
Plan faster. Explain more. Help the business respond to change in real time. That's the standing request most finance teams are working under right now, and it's a hard one to meet when the data behind the plan is still catching up to what's actually happening in the business.
Incorta powers the Adaptive Data Foundation to close that gap. It's a finance-owned data layer, purpose-built for Workday Adaptive Planning, that connects ERP systems, CRMs, HRIS platforms, and operational planning tools directly into Adaptive, with data refreshing as frequently as every five minutes.
Intelligent planning rests on three things: data readiness, access to rich actuals, and a real connection between plans and the decisions that come out of them. When any one of these breaks down, planning slows, trust erodes, and the decisions that follow lose their footing.
Most FP&A teams don't actually lack data. They lack the right data, at the right level of detail, at the right time. The problems show up the same way almost everywhere: actuals that arrive after the close, operational plans that never connect back to the financial model, and granular detail that's out of reach exactly when analysis needs it most. Adaptive Data Foundation is built to solve those three problems in a single layer.
Adaptive Data Foundation runs on Incorta's Direct Data Mapping technology and includes pre-built blueprints for Workday Financial Management and other enterprise platforms. It delivers full transaction-level access and keeps that data current in near real time, so finance isn't working from a periodic extract or a static summary. They're working from live, analytics-ready data that both people and AI agents can use directly.
What sets it apart from a typical enterprise data platform is who's in control. Adaptive Data Foundation is owned and operated by finance, not IT. FP&A teams can add data feeds, update definitions, and change models on their own timeline, without submitting a ticket or waiting on a backlog. For organizations that already have a mature data platform, it runs alongside it. For those that don't, it's the foundation that gets built in its place.
That live layer is what drives everything downstream. Operational signals, revenue run rates, pipeline shifts, headcount changes, inventory levels, spend commitments, feed continuously into forecasts, scenarios, and decisions, so the plan stays aligned with what's actually happening in the business instead of drifting further from it every week.
Behind the scenes, Incorta handles the complexity of pulling data across many source systems. What it publishes to Workday Adaptive is a clean, planning-ready view with full lineage and traceability built in. That's what makes it possible to expose rich, transaction-level actuals to planning without dragging all of that underlying complexity along with it.
Connecting Workday Adaptive to Adaptive Data Foundation comes down to configuration, not custom development. A team selects one view as the data source, GL balances, for example, and can select a second view as a drill-through target for deeper detail, like the journal lines behind those balances. Once that pipeline is in place, rich actuals flow straight into the plan.
From there, a planner can drill from a summary variance straight down to the originating transaction with a single click, without ever leaving Workday Adaptive or submitting a data request. The answer comes back inside the same workflow, so it's immediate and stays in context. When the next question comes up, and it always does, the same detail is already there. A user can start at a balance, move into journal lines, drop to customer-level detail, and see the order activity behind it, all without rebuilding a report or leaving the flow they're already in.
Adaptive Data Foundation isn't limited to reports and dashboards. The same governed framework is accessible agentically. An AI agent can discover the underlying schema, understand the business context around it, and answer complex questions in natural language, all against the same governed data a human analyst would use. AI-driven variance analysis can surface the operational driver behind a change instead of just the number, and AI-assisted scenario planning can incorporate live signals to generate and continually test forward-looking scenarios.
That means one foundation supports dashboards, planning, drill-through, and AI agents alike, without spinning up new pipelines or duplicating data for each use case. It simplifies access today, and it keeps the foundation ready for however your uplanning workflows keep evolving.
Watch the full demo here:
We polled the room on their biggest data headache, and one answer stuck out immediately:
More than half the room is still fighting Excel for control of their own numbers, and another fifth doesn't trust the data they do have. That's three out of every four attendees stuck at the most basic layer of the problem before they can even get to decision making.
Mike Nader, Field CTO at Incorta, and Ben Pierce, General Manager of Workday Adaptive Planning, walked us through what it actually takes to move finance from reporting the past to guiding what happens next.
1. Connect operational and financial data into a single governed access point. Not just a dashboard, but a place where a finance user can drill from a KPI down to the transaction that explains it.
2. Shift from analytics to decision making. Seeing an alert isn't enough. Teams need to understand why something is happening, model out a few scenarios, and act on it in the same period, not after the fact.
3. Let finance own its data, without losing governance. The goal is fewer tickets to IT for routine questions, not fewer controls. Owning the data and governing it aren't in conflict.
4. Build the foundation AI actually needs. AI doesn't fix broken data - it just makes the cracks more visible, faster. If financial context isn't connected to the rest of the business, AI has nothing solid to reason over, and every decision a company makes eventually shows up as a financial outcome anyway.
Mike's demo centered on Adaptive Decision Intelligence, now part of Adaptive Pro licensing. He asked it a series of increasingly specific questions about a top customer: purchase history, growth forecast, channel rankings. Then he asked one it couldn't yet answer: whether the customer's open orders, fulfillment rates, and cancellations pointed to a forecasting risk.
That's where he pivoted to the Adaptive Data Foundation, powered by Incorta, and showed how the underlying data gets there in the first place. It's pulled directly from source systems like SAP or Oracle, mirrored without transformation, then enriched with business rules that stay fully traceable. Every formula, every derived field, every source system it came from is logged in the data catalog and can be walked back on demand.
Ben, watching it live, compared it to solving a problem he's seen at nearly every planning customer: building a real semantic layer instead of forcing users to understand joins and pull raw tables out of a system like Oracle EBS by hand.
A few questions from the audience got at what teams actually want to know before adopting this.
Is this the same as the Adaptive Planning interface? No. Incorta and Workday have partnered for years, going back to a shared customer that connected the two products independently before the formal partnership existed. Workday now stands behind the Adaptive Data Foundation as part of its embed program, with joint product work on drill-through and security.
How does security work across both systems? Templates mirror Adaptive's security model directly in the data foundation. If a user can't see certain revenue lines in Adaptive, they won't see them in the transaction-level data either.
Does data need to be cleaned before it connects to Incorta? No. Mike was emphatic that data should land exactly as it looks in the source system, with enrichment and rules applied afterward, not during ingestion. That preserves lineage instead of hiding it.
How do you keep an AI agent from acting on a number that's technically correct but contextually wrong? Mike's answer came down to scope: define the job the agent is doing, then define exactly which actions are legitimate for it to take, whether that's answering a question or actually modifying a plan. Everything stays inside the same governance model as the rest of the platform.
Every data team knows the feeling. You build the dashboard, the semantic layer, the governance model. Then a business user downloads the data to Excel anyway, or pastes it into a chatbot, because the platform can't get them to the last step: taking action.
That gap between insight and action was the focus of our recent launch webinar for Incorta Builder and Incorta Intelligence. Mark, our Head of Product Marketing, hosted the session with Ashwin, VP of Product, and Anurag, VP of Product Management, walking through the new capabilities and running live demos of what business users can build without writing a line of SQL. The full session is available on demand if you want to watch it end to end. Here's a recap of what shipped and why it matters.
Mark opened with three patterns that show up at nearly every company:
Insight doesn't lead to action. Dashboards and BI tools surface what's happening, but taking action still means jumping to another system. Now that gap includes chatbots. Teams pull data out of governed platforms and drop it into AI tools with little to no oversight, and adoption stalls.
Innovation sits in a queue. Either IT can't build custom apps fast enough, or the business ends up with a sprawl of small SaaS tools, each doing one thing, none of them talking to each other.
The cost adds up. Mark cited research showing over 60% of workers' time goes to work about the work: prepping data, hunting for access, merging systems. 74% of companies can't scale AI because of governance gaps. Six in ten IT teams have app backlogs they can't clear, and large enterprises are sitting on an average of $18 million in excess SaaS spend a year.
The fix isn't another point solution. It's giving business users a way to build what they need on top of data that's already governed, so nothing new has to be reinvented or re-secured.
Ashwin introduced the next layer of the platform. What used to be called Nexus is now Incorta Intelligence, and it's built on the same data foundation Incorta customers already have: the pipelines, the semantic layer, the direct data mapping that turns a 40-table star schema into one clean business view an AI model can actually query.
On top of that foundation sit three pillars:
All of it runs on the Smart Agent, which is where the actual query generation and reasoning happen.
A fair question came up during the session: why not just export data and hand it to a frontier model? Ashwin walked through what he called the hidden AI tax.
Frontier models are powerful, but they don't know your data. Every complex question means re-explaining the schema, re-joining tables, and re-running the same expensive query someone already ran last week. Incorta's Smart Agent works differently because it sits on top of a data foundation that's already curated: pre-built business views, established relationships across tables, dashboards and queries you've already written that can be reused instead of rebuilt from scratch.
Add response caching, query caching, and business context you can enrich directly in Incorta's data catalog, and the cost difference compared to raw frontier-model usage is significant, without giving up governance or row-level security.
The bulk of the webinar was live demos, and they followed a clear progression: ask a question, get a report, turn that report into something interactive.
HTML dashboards, built from a prompt. Anurag showed four examples: a monthly financial close summary, a quarterly business review, an annual board and investor report, and a product launch analysis (using Incorta's synthetic Apple dataset to track how iPhone 17 performed against iPhone 16). Each one started as a plain-language prompt and came back as a polished, interactive HTML report in a few minutes, no dashboard design or SQL required.
Static reports turned into live apps. A monthly report is only useful for that month. Anurag showed how the same dashboard can be redeployed as a live Incorta app, with filters that run real queries against live data instead of a snapshot.
A gallery for managing every dashboard you've created. If you're generating dozens of these reports a month, you need somewhere to find them again. Anurag built a simple app, in under half an hour, that lets users upload, tag, search, and organize every HTML dashboard by category, all inside Incorta's existing governance model.
A forecast and planning app with real write-back. This was the demo that showed what "action" actually looks like. Users could review a 12-month revenue trend, generate a forecast, then plan by product and region directly in an Excel-like grid, adjusting units and revenue by month. Saving the plan writes to a Postgres database that syncs back to Incorta immediately, and the same write-back pattern extends to ERPs or systems like Workday Adaptive Planning through REST API or JDBC.
An internal resourcing app, built entirely on a custom schema inside Incorta, to track consultant utilization and flag overallocation in real time.
Claude generating an app through Incorta's MCP server. The last demo tied it together: Anurag prompted Claude to build a sales comparison dashboard using an Incorta business view, then asked Claude to convert it into a full AI app with product and country dropdowns. The Smart Agent, running inside Claude through Incorta's MCP server, generated the SQL. Anurag deployed the new version, tested it, and published it, all without leaving the Incorta environment.
A question from the audience got at something worth calling out directly: does row-level security carry over to these new AI apps, or is it a separate mechanism?
Ashwin's answer was straightforward. It's the same underlying security model used for dashboards today, the same user predicates, the same session variables. Anything built with the Smart Agent or Incorta Builder inherits that governance from the start. Nothing new to configure, nothing new to audit.
Smart Agent capabilities are live in Incorta's current release. AI Apps are on track for general availability by the end of July, with early access open now for customers who want in ahead of GA.
Also on the roadmap: tighter native support for layout.dev alongside the existing Streamlit and Python options, giving developers another path to build richer last-mile visualizations inside Incorta apps.
This recap covers the highlights, but the demos are worth watching in full, especially the live app-building sequence with Claude and the forecast and planning walkthrough.
The webinar recording is available on demand, and if you want early access to AI Apps or a personalized demo, reach out to the Incorta team directly.
We spend a lot of time evaluating AI models on benchmarks, but in practice, model quality is only part of what drives useful output. The more decisive variable is context: what information the model has access to, how relevant that information is to the task, and how efficiently it gets retrieved.
Context engineering is the discipline of getting that right. It covers how you structure prompts, what data you pull in, when you pull it, and how you avoid flooding the model with noise that dilutes the signal.
MCP addresses a core challenge in context engineering. Traditionally, teams would hardcode knowledge into a model through fine-tuning, or pre-load large volumes of data into a prompt and hope the model extracts what it needs. Both approaches are brittle. Fine-tuned knowledge goes stale. Oversized prompts waste tokens and blur focus.
MCP gives agents a better option: retrieve what they need, when they need it, from authoritative sources.
One of the patterns I find most compelling in MCP adoption is how it changes the relationship between an agent and enterprise knowledge.
Instead of embedding domain knowledge into the model at training or prompt time, the agent uses MCP to pull relevant documents or data at runtime. The agent stays lightweight. It doesn't carry context it doesn't need. But when it does need enterprise-specific information, whether that's a policy, a schema definition, a historical report, or a data asset, it can reach for it on demand.
This has direct implications for analytics and data-intensive workflows. At Incorta, we work with organizations that have deep, complex data estates. The ability for an agent to surface the right slice of that data at the right moment, grounded in actual enterprise context rather than generic reasoning, is what makes agentic workflows viable in production environments.
Looking ahead, I think MCP's role will expand significantly. Right now, most teams are using MCP servers to retrieve documentation, pull from internal knowledge bases, or connect coding agents to production data. That's valuable, and it's clearly resonating: MCP adoption has accelerated sharply, and context retrieval is consistently cited as its primary use case.
But retrieval is just the starting point.
As software becomes increasingly agent-driven, the demand for agents to not just access context but coordinate across it will grow. An agent working on a data pipeline might need to reason across schema documentation, historical query performance, upstream data quality signals, and downstream consumer requirements, all at once, all in real time.
In that world, MCP becomes the control plane agents use to access context, tools, and actions. It's the infrastructure layer that makes complex, multi-step agentic reasoning practical at enterprise scale. Much like REST APIs became the standard interface for service-to-service communication, MCP-like abstractions are on a path to becoming standard infrastructure for agent-to-data communication.
That's a significant architectural shift. Teams that build with that in mind now will be better positioned as agent-driven software matures.
The implications are particularly sharp for platforms like Incorta that sit at the intersection of enterprise data and AI.
If agents increasingly rely on MCP to retrieve structured, governed, analytics-ready data at runtime, then the quality and accessibility of that underlying data layer matters more than ever. An agent is only as grounded as the data it can reach. Hallucination in agentic workflows is often less about model failure and more about context failure: the agent didn't have access to the right data, or the data it accessed was stale, incomplete, or unstructured.
Investing in clean, well-governed, high-fidelity data isn't just a data hygiene exercise. In an agentic architecture, it's a prerequisite for reliable AI output.
MCP is already playing a real role in how AI systems retrieve and use context. The teams I see getting the most value from it are the ones treating context engineering as a first-class engineering concern, not an afterthought.
As agent-driven software continues to evolve, MCP will be part of the foundation. Getting ahead of that now, understanding how your data is structured, how it can be retrieved, and how agents will interact with it, is work worth doing today.
Ebrahim Alareqi is the Principal Machine Learning Engineer at Incorta, where he works on AI systems and ML infrastructure. He was recently quoted in InfoWorld's feature on the role of MCP in context engineering.
The latest updates and resources from us, directly to your inbox. (No spam, we promise!)