.svg)
I've been coming to this conference for about twenty years. I've watched it evolve through the JBoss/Red Hat era (open source as a platform), through CloudBees and the rise of DevOps, through OutSystems and the low-code wave. Each cycle, a new category forms at this conference before it forms anywhere else. This year, at Caesars Forum Conference Center, surrounded by the usual vendor noise and Gartner analyst sessions packed wall to wall, it felt like another one of those moments. The category forming now is enterprise AI grounding, and it's moving faster than any of those previous cycles did.
What Gartner Told the Market
I attended several key analyst sessions. The content was striking in how directly it mapped to the problem CoreStory addresses.
The AI application development platforms market is growing at over 30% annually and is projected to exceed $5.2B. The pace was fast enough that Gartner did something rare: a mid-cycle Magic Quadrant update to keep up. That alone signals how quickly this market is moving.
But the more significant signal was not the size of the market. It was what Gartner said about what the market requires. According to the sessions we attended, mandatory platform capabilities now include model grounding, guardrails, governance, and evaluations. Grounding is no longer a differentiator. It is table stakes. Gartner has institutionalized the concept.
For us, hearing "grounding" named as a required capability in a Magic Quadrant was the clearest external validation we have received of our category positioning.
The enterprise coding agent sessions were equally direct. Mandatory capabilities for enterprise AI coding agents now include context awareness and governance, alongside MCP support. The analyst framing described three structural vendor types in the market. One of those types was "context-driven approaches," vendors that differentiate by grounding agents in enterprise context rather than just providing a better model or developer UX. The sole Visionary placement in the coding-agent Magic Quadrant went to a vendor whose bet is exactly this: that enterprise context is the primary differentiator, built around a context engine that grounds agent behavior in code, policies, and organizational structures.
That is CoreStory's thesis, stated back to us by Gartner's own market categorization.
The closing analyst guidance reinforced the pattern: anchor your AI strategy in specific use cases, cost, accuracy risk, and governance. Not vague "add AI" mandates. Scaffold around agents to ground them in enterprise context and verify outputs. Build a roadmap from coding to orchestration with grounding as the foundation.
We also presented a session on agent grounding, where we shared the three practices that make grounding work in production:
- Spec-driven development: atomic, hierarchical specs as the source of truth for agent behavior.
- Living intelligence: specs auto-updated via CI/CD on every commit and PR.
- Trust: every spec element linked to code, complete, and auditable.
The quantified outcomes from grounded deployments are material: roughly 50% higher task accuracy, around 15% faster completion, and approximately 70% fewer tokens per task, measured across Codex, Claude Code, Copilot, and Cursor.
What the Floor Told Us
We talked to hundreds of people across the four days. The booth conversations were independent of the analyst sessions, and the overlap was near-total.
Four themes came up again and again, unprompted.
- Legacy complexity is the dominant problem. The largest single cohort of conversations came from state and local government organizations. Behind them, insurance and healthcare payers. Banking. Defense. Energy. In every case, the story was the same: COBOL estates, mainframe systems, .NET applications built over decades by teams that have long since moved on. Organizations where the person who knows why a critical system works the way it does is either retired or unreachable. The AI tools these organizations have already deployed are failing on exactly the code that matters most.
- Tribal knowledge loss is reaching a crisis point. Several teams described situations where a critical system had accumulated so much undocumented complexity that their own engineers could not reliably explain why it behaved the way it did. One phrasing that stuck: "we have so much code we don't know why we built it." That is a business intelligence problem before it is a software problem, and it is the exact problem that spec extraction solves. The business analyst use case surfaced in multiple conversations without us introducing it.
- AI tool cost and inconsistency are frustrating engineering leaders. We heard from multiple organizations about significant token spend with disappointing output quality. One recurring pattern: different developers on the same team getting different results from the same AI coding tool on the same codebase. The root cause in each case was the same — agents working without grounded context of the system are pattern-matching against training data, not understanding the specific code in front of them. The variability is a symptom of that absence.
- Governance and blast radius concerns are blocking broader adoption. Several engineering leaders framed their AI adoption challenge as a governance problem. They were not opposed to AI-assisted development. They were opposed to changes propagating through production systems without anyone being able to trace where the change came from, why it was made, or what it might break. Grounding is also the answer here: when every agent decision is anchored to a verifiable spec tied to the actual code, traceability becomes straightforward.
The validation quote of the conference came from a senior director of software development: "Totally understand the approach, it solves a problem we have."
That was the moment that crystallized everything. Not a prospect being polite. An engineer recognizing a problem they live with and seeing a solution they understood.
Why They Match
The convergence was not a coincidence. Gartner was describing the market from the analyst vantage point. The booth conversations were describing the same problem from the practitioner vantage point. They arrived at identical conclusions.
The problem is context. AI models are not getting worse. If anything, they are getting better faster than most organizations can absorb. But model capability without grounded, persistent understanding of the specific system an agent is operating on produces exactly the failure modes that every engineering leader at this conference described: inconsistent outputs, invisible blast radius, hallucinated APIs, business logic missed entirely.
The framework we shared in our session is also the framework that works in production. Spec-driven development gives agents an authoritative source of truth to work from, not a best-effort text search. Living intelligence keeps that source of truth current as the codebase evolves. Trust, meaning every spec element traceable to real code, is what makes governance possible.
For enterprise organizations with large or legacy codebases, this is not a future state. It is the necessary architecture for making AI work on the code that actually runs your business - not just the greenfield services but the payment systems, the claims processors, the mainframe workflows that have been running since before the current engineering team was hired.
What Comes Next
We came back from Las Vegas with a clearer picture of where the market is heading and where enterprises are actually stuck.
If you are an engineering leader dealing with any of the patterns described above (legacy complexity, tribal knowledge loss, inconsistent AI tool output across your team, or governance concerns blocking broader AI adoption) the context problem is almost certainly the root cause. And the solution is not a better model. It is a persistent intelligence layer that understands your system.
CoreStory builds that layer. If the conversations above resonate, talk to an expert to see what this looks like on your actual codebase. Or explore how enterprise teams are giving AI coding agents better codebase context in practice.
