The AI agent observability space is taking off — but how can enterprises be sure what observability products and solutions they need?
Observability startup groudcover (lower case “g” intentional) announced this week that it raised $100 million in a round led by One Peak, bringing its total funding to $160 million.
The company says it has more than 250 paying customers, tripled annual recurring revenue over the past year and is increasingly replacing established observability platforms inside enterprise environments. Those are company-reported figures, but together they point to growing momentum in one of enterprise software’s most competitive markets.
That market has long been dominated by companies including Datadog, Dynatrace, New Relic, Splunk and Grafana. Between them, they represent billions of dollars in annual revenue and years of product maturity. Breaking into that group has never been easy.
groundcover’s argument is that artificial intelligence has fundamentally changed the assumptions those platforms were built on.
Rather than competing feature for feature, the four-year-old company is trying to convince enterprises that the architecture underpinning observability itself needs to change as AI systems become more autonomous, produce vastly more telemetry and increasingly participate in software operations. Whether that thesis proves correct remains an open question, but it offers a compelling lens through which to examine how observability is evolving alongside enterprise AI.
Observability has traditionally been viewed as a post-production discipline. Engineers deploy applications, monitor logs, metrics and traces, investigate incidents, and improve reliability over time.
That workflow is changing.
AI-assisted software development has dramatically accelerated deployment cycles. Coding assistants generate more code, infrastructure evolves more rapidly, and organizations are deploying increasingly complex distributed systems that combine microservices, Kubernetes clusters, APIs and large language models. At the same time, enterprises are beginning to operate AI agents that execute multi-step workflows, call external tools and interact with production systems.
Each of those activities generates telemetry.
The result is an explosion of operational data that organizations increasingly want to retain rather than discard. AI applications introduce additional layers of observability beyond traditional infrastructure monitoring, including prompt execution, model latency, token consumption, retrieval pipelines, tool invocations and agent behavior. As enterprises experiment with autonomous systems, that telemetry becomes increasingly valuable because it provides the context needed to understand what an AI system actually did and why.
For many organizations, this creates tension with pricing models that charge according to the amount of data ingested.
Historically, engineers have often responded by sampling traces, shortening retention periods or limiting which data is collected. Those approaches reduce costs, but they also reduce visibility precisely when AI-driven systems demand more complete operational context.
“We’ve seen telemetry exploding,” groundcover co-founder and CEO Shahar Azulay said during a recent media briefing. “Users are frustrated by not getting all the value from Datadog and similar platforms. They’re limiting the data, siloing it, sampling it.”
Whether that frustration is widespread enough to reshape the market remains to be seen, but the underlying trend is difficult to ignore. AI is making observability less about collecting enough data and more about collecting everything organizations may eventually need.
Many observability vendors have introduced AI assistants, AI-powered root cause analysis and AI observability features over the past two years. Datadog, Dynatrace, New Relic and Grafana have all announced products aimed at helping enterprises monitor AI applications or automate operational tasks.
groundcover acknowledges those developments but argues they do not address what it sees as the more fundamental issue: where telemetry lives and how customers pay for it.
Instead of operating a conventional SaaS platform that stores customer telemetry in vendor-managed infrastructure, groundcover uses what it calls a bring-your-own-cloud (BYOC) architecture.
Customers keep the data plane—including telemetry storage and processing—inside their own AWS, Microsoft Azure or Google Cloud environments, while groundcover provides a managed control plane and user experience. A fully self-hosted deployment option is also available.
While some competitors, including Datadog and a few other observability vendors, do offer limited hybrid or customer-controlled data residency options, these are generally not equivalent to a full BYOC model. In most cases, telemetry is still processed and stored within the vendor’s managed infrastructure, with only partial controls (such as regional data residency, private links, or selective log forwarding) available.
That architectural decision influences nearly every aspect of the company’s strategy.
Because customers already pay for their own cloud infrastructure, groundcover argues it can avoid charging based on telemetry ingestion. Instead, pricing is based primarily on monitored hosts, regardless of telemetry volume.
The company believes this changes customer behavior.
Rather than deciding which logs or traces are too expensive to keep, organizations can theoretically retain complete telemetry and use it for operational analysis, compliance and AI-assisted troubleshooting.
“We don’t price by data volume,” Azulay said. “We price by the size of the infrastructure.”
The distinction matters because AI workloads tend to increase telemetry far faster than infrastructure itself.
That does not necessarily make host-based pricing universally cheaper. Organizations with relatively light workloads spread across many hosts may find different economics than dense Kubernetes environments generating enormous amounts of telemetry. The company’s own briefing notes that per-host pricing is most advantageous for organizations with high telemetry density and may be less compelling for lightly utilized fleets.
Still, the broader argument is less about cost alone than predictability. Enterprise infrastructure teams often struggle with observability bills that fluctuate alongside application growth. groundcover’s model attempts to align pricing more closely with infrastructure planning rather than data generation.
The second pillar of groundcover’s strategy is eBPF, a Linux kernel technology that has rapidly become one of the most important building blocks for modern cloud observability.
Instead of requiring developers to manually instrument applications, eBPF allows software running inside the operating system kernel to observe network traffic, system calls and application behavior with minimal code changes.
That enables faster deployment and broader visibility across infrastructure.
For organizations operating Kubernetes clusters and cloud-native applications, reducing instrumentation complexity can significantly shorten deployment times while increasing telemetry coverage.
Azulay argues this becomes especially important as AI systems generate increasingly complex interactions across services.
“Our sensor allows us to observe systems very deeply from infrastructure to application to AI workloads without developers needing to instrument code,” he said during the briefing.
eBPF itself is hardly unique. Many observability vendors now incorporate it into their platforms.
What groundcover argues differentiates its approach is combining automatic eBPF collection with customer-controlled storage, OpenTelemetry compatibility and unified pricing inside a single platform.
The company’s own research briefing acknowledges that none of these technologies individually represents a competitive moat. The claimed differentiation lies in the combination of eBPF-first collection, managed BYOC architecture, host-based economics and full-stack observability delivered together.
Perhaps the most interesting aspect of groundcover’s strategy extends beyond traditional monitoring.
The company increasingly describes observability as infrastructure for autonomous software development.
Historically, observability platforms have served human operators investigating production incidents.
groundcover believes future observability platforms will increasingly serve AI agents as well.
Its Agent Mode product allows engineers to investigate incidents using natural language across logs, metrics, traces and Kubernetes events. More importantly, Azulay envisions observability becoming the feedback mechanism that informs coding agents about what actually happened in production.
Rather than simply detecting failures after deployment, observability becomes continuous operational context that autonomous systems can use to evaluate changes, identify regressions and eventually recommend or implement fixes.
“We’re seeing observability moving from being a post-production tool… to people taking context from production and feeding it back to their coding agents so they can write code better,” Azulay said.
Today, the company emphasizes that humans remain in the loop.
Agent Mode investigates incidents and surfaces recommendations, but production changes still require human approval. Azulay expects autonomy to increase gradually as organizations become more comfortable allowing AI systems to participate in operational workflows.
That vision reflects a broader trend emerging across enterprise software, where AI agents increasingly span development, testing, deployment and operations rather than functioning as isolated assistants.
groundcover is entering an intensely competitive market populated by vendors with decades of enterprise experience.
Datadog alone generated more than $3 billion in annual revenue in 2025. Dynatrace, Cisco’s Splunk business, Grafana Labs and New Relic all maintain extensive partner ecosystems, mature integrations and enterprise support organizations that newer entrants cannot easily replicate.
groundcover is not attempting to outscale those incumbents overnight.
Instead, it argues that AI creates an architectural inflection point similar to previous transitions from on-premises infrastructure to cloud-native computing.
According to Azulay, many customers initially adopt groundcover to reduce observability costs but increasingly remain because they want unrestricted access to richer telemetry and AI-native workflows.
He says deployments typically replace incumbent platforms rather than operate alongside them, although the company has not publicly disclosed customer migration data or independent studies validating that claim.
The company’s journalist briefing also urges caution around some performance claims.
Revenue growth, customer counts and enterprise adoption figures originate from groundcover itself. Published customer case studies reporting significant cost savings are vendor-authored and should not be treated as independent validation without additional evidence. The briefing also recommends scrutinizing exactly what metadata leaves customer environments in standard BYOC deployments, rather than assuming that no operational data ever reaches vendor infrastructure.
Those caveats are important because the observability market has become crowded. Gartner currently tracks more than one hundred observability products, and nearly every major vendor now markets AI-powered operational capabilities.
Success will likely depend less on whether AI matters—which increasingly appears inevitable—and more on whether enterprises conclude that existing architectures remain sufficient.
Viewed narrowly, groundcover’s Series C is another large infrastructure funding round.
Viewed more broadly, it reflects a growing debate about what observability becomes in an era where software increasingly writes, tests and operates itself.
If AI continues generating exponentially larger volumes of operational data, traditional assumptions about telemetry collection, pricing and storage may come under increasing pressure. Vendors that built businesses around charging for data ingestion may need to evolve their economics alongside customer expectations. New entrants, meanwhile, have an opportunity to design around those changing assumptions from the outset.
groundcover believes that opportunity lies in combining customer-controlled infrastructure, automatic telemetry collection and AI-assisted operations into a platform designed for autonomous software rather than simply adding AI features to existing observability products.
Whether that architectural bet proves durable will depend on enterprise adoption over the next several years.
But the company’s latest funding round suggests at least some investors believe the next battle in observability will not be fought over dashboards or alerts. It will be fought over who builds the operational data layer that increasingly intelligent software relies upon to understand—and eventually manage—the systems it runs.
You spend weeks tuning an AI chatbot. Answers are accurate. Stakeholders sign off, and you ship it. Three months later, the system is confidently wrong about a third of what users ask. Nobody changed the model, and nobody touched the prompts. The world moved, pricing changed, a policy updated, a product spec shipped a new version, and the underlying knowledge store didn’t move with it.
This is not a hypothetical. It’s one of the most common production failure modes in enterprise AI right now, and most data engineering teams don’t have the right tooling to catch it, regardless of how the AI system retrieves the data.
An AI application doesn’t care whether it’s retrieving from a vector store, a document index, or an API call. Whatever the mechanism, nothing in a standard retrieval pipeline checks whether what it’s serving is still correct. A stale pricing document retrieves just as confidently as a current one, because the system is scoring relevance or availability, not correctness. A record with a silently missing field passes through just as cleanly as a complete one, for the same reason.
So the failure is invisible by design. Outdated or incomplete data still scores high on relevance, or passes every check a data pipeline was built to run. The model answers with full confidence because the retrieved context looks authoritative. Every dashboard you’re watching stays green. The system looks like it’s working. It’s just wrong.
I’ve watched a similar version of this happen outside the AI context, in a fintech pipeline. An upstream system changed a field without notifying downstream users. The pipeline did not fail; it simply propagated bad values into dashboards because the system only checked whether the job completed, not whether the data was still correct. The issue surfaced only when a customer noticed something inconsistent. By then, the bad data had already moved downstream.
Whether it’s a document that’s gone stale or a field that’s gone silently missing, the failure shape is the same: the absence of an error is not the presence of correctness, and without building proper validation layers, nothing in the pipeline could identify the problem.
Teams that hit this failure tend to misdiagnose it, and they tend to do it twice.
Blaming the model: The first instinct is to blame the model, try a different LLM, adjust the prompt. The real problem lies further upstream, at the data engineering layer, the same instinct behind the fintech failure above: monitoring built for the pipeline, not the data.
Blaming the retrieval layer: Once the model’s ruled out, the next instinct is to blame the retrieval or context layer instead and buy a better one. The timing isn’t a coincidence: as enterprises push these systems into the real production world, this gap is exactly what’s starting to surface, and the vendor response has been everywhere.
AWS just entered the “context layer” race with a knowledge graph that learns from agent usage.
Snowflake’s new Horizon Context and Cortex Sense target the exact symptom this piece opened with: agents giving confident wrong answers because nothing governs the business logic underneath them.
Both are real responses to a real problem, but they sit one layer above it; a knowledge graph still depends on whatever feeds it.
The real problem lies further upstream, at the data engineering layer. Teams check whether a job ran, not whether the data it moved is still true, an instinct that predates AI by years. Monitoring is built for the pipeline, not for the data.
Data observability is a well-known concept that doesn’t get enough attention in how it’s actually implemented. The relevant metric isn’t a percentage — it’s coverage: what fraction of critical datasets have lineage that’s actually queryable, versus only living in someone’s head.
Uber built a dedicated data quality and observability platform long before retrieval-augmented generation existed. Their Unified Data Quality platform supports more than 2,000 critical datasets and detects around 90% of data quality incidents before they reach downstream consumers.
Netflix solved a different piece of the same problem, building a company-wide data lineage system so anyone could answer where a dataset came from and what touched it along the way. It maps dependencies across Kafka topics, ML models, and experimentation, not just warehouse tables. Similar to Uber, the platform was built for humans and now it has become more important with the rise in AI/LLM applications.
Between them, Uber and Netflix cover two of the four things worth building for. In practice, I think about it as four dimensions, each measurable on its own terms.
Correctness: Does each record conform to the shape and rules it’s supposed to, right field types, no unexpected nulls, values in range. Tools like Great Expectations and Soda handle this well: automated row and column-level validation instead of manual checks after something breaks. Track percentage of records passing validation per run.
Freshness: Is the data still current relative to its source, not just current as of its last check. Track time since last successful update per source, with an SLA per dataset rather than one blanket threshold, since some sources need hourly refresh and others don’t.
Consistency: Does the same fact read the same way everywhere it’s stored or indexed. This fails silently, it only shows up when two systems fed by the same source start disagreeing. A periodic cross-check between downstream destinations, flagging mismatch rate above a threshold, is enough to catch it early.
Lineage: Can you trace any output back to its source and every transform it passed through, the same question Netflix built its system to answer.
None of this requires infrastructure most data teams don’t already have. I know because I’ve built it, not just argued for it.
At Socure, client data arrived in whatever shape the client felt like sending it, and occasionally, quietly wrong. The challenge was building a system where incorrect data could be identified before it propagated downstream. The same principles applied: Validate what arrived, understand where it came from, and prevent bad data from becoming someone else’s problem.
Great Expectations became part of that foundation: schema and range validation at ingestion, per-source SLAs for freshness, cross-system checks for consistency, and file-level lineage. All of it sat behind a write-audit-publish pattern, where data landed in staging, was validated, and only moved downstream if it passed the required checks.
The result showed up downstream: better accuracy across the board, in reporting, in the ML models, and in AI retrieval built on top of that same data.
If you’re running retrieval-based AI systems in production, the diagnostic question isn’t which model to try next or which retrieval architecture to migrate to. It’s four narrower questions:
Is the underlying data validated against the standards required by its consumers?
What’s the oldest piece of content currently being served with high confidence?
Would two chunks of the same source ever disagree with each other in the same retrieval result?
Could you trace where it came from if it turned out to be wrong?
If you can’t answer those questions, then the gap lies in the pipeline between your source systems and whatever your agent reads from. That’s a data engineering fix, not a model swap or a vendor migration.
Whether you’re building reporting pipelines, ML systems, or AI agents, correctness, freshness, consistency, and lineage are what make data trustworthy. AI simply exposes weaknesses that have existed in data engineering all along.
GPU memory is the most expensive resource in production AI, and it’s also the one running out fastest.
Long context windows and multi-turn conversations force AI models to repeatedly recompute information they’ve already processed, consuming GPU memory and compute that could otherwise serve additional users or generate new responses.
Instead of treating GPU memory as the limiting resource, why not extend it with much cheaper storage technologies?
Weka, for one, believes that cheap flash storage can close that gap. The company’s NeuralMesh 6 software platform, launching alongside its first self-designed hardware line, Wekapod 3, extends what Weka calls Augmented Memory Grid, an approach that aggregates NAND flash to behave like GPU memory at a fraction of the cost.
This is an active and increasingly crowded category. Dell, NetApp, Pure Storage and VAST have all repositioned toward AI infrastructure over the past two years and Weka is one of several vendors arguing it’s built for this specific moment rather than adapting to it.
“What we’re seeing now with customers is they’re chasing availability of compute, and once they get new allocation from anyone, they want to be able to grab it and start running right away,” Weka co-founder and CEO Liran Zvibel, told VentureBeat.
The potential payoff is straightforward: better utilization of existing GPU investments, lower inference costs and faster deployment of new AI workloads without waiting months for additional GPU capacity.
The technology is most relevant for organizations already operating AI at scale or expecting rapid growth in usage, particularly enterprises building internal copilots, customer service agents, software engineering assistants or retrieval systems with long context windows. Smaller deployments may see less immediate benefit than organizations where GPU utilization has already become a limiting factor.
NeuralMesh 6 adds four capabilities aimed directly at a functionality gap Zvibel says has been costing Weka deals in competitive evaluations.
Composable and virtual multi-tenancy. Composable clusters give anchor tenants full hardware-level isolation, dedicated CPU, memory, and storage. Virtual multi-tenancy runs through Weka’s RDMA fabric, delivering network-level isolation that scales past 1,000 tenants per cluster, with provisioning in under 30 minutes. Combined, a single cluster running 50 composable clusters can support up to 50,000 tenants.
Unified file and object storage. Most storage systems keep two separate paths: a file-based path (the standard way servers and applications read and write files, used heavily in training and fine-tuning pipelines) and an object-based path (S3, the format inference and cloud-native tools typically expect). Normally a gateway translates between the two, meaning the data effectively exists twice. Weka’s claim is that the same physical data on disk is directly readable through either path at once, no translation layer, no second copy. Zvibel is targeting non-AWS GPU clouds specifically, naming Lambda, Nebius, G42, and CoreWeave, with what he described as roughly two orders of magnitude higher performance than conventional S3 and a capacity-based pricing model instead of per-API charges.
Metadata-first replication. Destination environments become browsable before a full data copy arrives, with data hydrating only when accessed.
“They had to wait for all of that to make it to the other side, and this takes days or weeks, in extreme cases a month,” Zvibel said. “We now allow our customers to grab some allocation of new GPUs and get up and running within an hour.”
AlloyFlash and Always-On data reduction. TLC and QLC are two types of NAND flash memory. TLC is faster and more durable but costs more per terabyte, while QLC is cheaper and holds more data per chip but is slower. AlloyFlash mixes both within a single cluster, automatically routing latency-sensitive work to TLC while running bulk-capacity workloads on QLC, cutting cost per terabyte without a performance penalty on the work that needs speed. Data reduction now runs by default rather than as an option.
Multi-tenancy and object storage solve how enterprises and neo clouds operate the platform day to day. A harder problem sits underneath: as context windows and multi-turn interactions grow, so does the GPU compute wasted recalculating work a model has already done. Augmented Memory Grid, a NeuralMesh 6 feature built specifically for this, is Weka’s answer.
Every prompt triggers two stages. Prefill calculates attention, the core mechanism behind how large language models process input, and it’s computationally expensive. Decode converts that calculation into output and is comparatively lightweight.
The cost shows up hardest in multi-turn sessions like chat or coding, where each new turn re-triggers prefill for everything that came before it, unless that work has been cached.
“If you have 10 turns, you may overcalculate 100 times because you’re redoing all of them. If you have 20, you’ll overcalculate 400 times,” Zvibel said. “You can put two orders of magnitude more NAND than you could afford in shared memory, and we can cache 100% of the pre-calculated tokens, so you never need to redo it.”
Storage vendors have spent the past year and a half repositioning around AI, and separating genuine capability from repositioned messaging is now a real evaluation problem for buyers.
“The storage world is shifting its focus from serving bits to enterprise workloads to managing data at the speed of AI. We’ve seen that most clearly over the past 18 months from Dell, NetApp, and Pure,” Steve McDowell, chief analyst at NAND Research, told VentureBeat. “The interesting thing is that companies like Weka, and VAST, are the true AI-native data companies, solving these problems since day one.”
McDowell singled out Augmented Memory Grid as Weka’s clearest technical lead.
“Weka continues to have the most technically capable KV cache implementation on the market with its Augmented Memory Grid,” he said. ” They were early with this technology, and continue to innovate. This is critical for AI inference, as it enables a level of GPU efficiency that, without question, saves money on GPUs and memory. That’s key for today’s memory and GPU constrained market.”
He also flagged Weka’s contractual guarantee on its data reduction claims as underappreciated.
“One flying a little under the radar: Weka is putting its money where its mouth is with its contractual guarantees for its data reduction promises,” he said.
McDowell’s advice to buyers evaluating competing claims from Weka, VAST, Pure and NetApp alike was pointed suggesting that enterprise buyers should look hard at what vendors are promising versus what they’re actually delivering.
“A smart buyer will look at how competing vendors are solving real-world problems today,” McDowell said. ” They do this by talking to organizations running similar workloads at similar scale. If a vendor can’t point to that, then it should be a warning sign.”
A single AI agent conversation can look flawless scored on its own and still point to a broken product. That gap is driving a shift in how enterprises evaluate agents, away from scoring individual traces and toward comparing cohorts of users against a baseline.
At VB Transform 2026, Harrison Chase, CEO of LangChain; Hui Zhang, CTO and co-founder of Conviva; and Emmanuel Turlay, director of engineering at CoreWeave, described that shift, along with a parallel move toward cheaper, narrower judge models.
Agent-as-judge — judging one AI agent’s output with another — hasn’t replaced LLM-as-judge, which Chase said remains the default. The larger tension, Zhang said, is between automated judging, whether by LLM or agent, and human review.
“You have scalable but ungrounded, whether it’s agents as judge or LLMs as judge, you grade the outcome, you grade the work. It still is very difficult to ground it and then you use humans and that’s just not scalable,” Zhang said. “The whole industry is facing this, which poison you want to pick.”
That gap — a conversation that scores well but still signals a broken product — is what teams try to close by building an exhaustive evaluation suite before they ship anything. Chase said that doesn’t work.
“We sometimes see teams that have almost eval paralysis,” Chase said. “They’re like, this is an eval set, I can’t launch it. The best teams launch and then iterate.”
Chase framed evaluation criteria as a living specification, not a one-time test suite: a product requirements document — the standard software-development spec for what an application should do. “Evals are like the new PRD,” he said. “They define what your agent should and shouldn’t do.”
Turlay described hitting the same failure from a different angle. “I was trying to reach 100% coverage for my tests, and I still had bugs in production,” he said — a test suite that looked complete but still missed what mattered, the same gap Chase was describing with evals.
Broad, always-on monitoring, he said, catches more real failures than an exhaustive pre-launch test suite. Teams should set up wide online checks first, use those to identify failure classes as they occur, then build a targeted offline evaluation set around the problems that surface.
Even a well-built evaluation process can still score the wrong thing. Zhang’s objection is to how most teams run evaluation: sampling traces, whether 50 of them or a full population, scoring each in isolation. That approach misses a signal that only shows up when comparing cohorts of users against a baseline, a method Zhang calls contrastive analysis.
Zhang illustrated it with a retail example: a shopper asks an agent for a running shoe ahead of a half marathon, the agent asks qualifying questions, and the shopper buys a shoe. Scored individually, that interaction looks fine. But the clarification ratio, how many follow-up questions an agent asks before completing a task, came in three times higher than baseline for that shoe category across the full user population. A second metric, how often shoppers finished their purchase outside the conversation, was five times higher than baseline for the same category.
Neither number is visible from a single trace. Both point to a debuggable, category-specific problem. Zhang said the industry also lacks a second data source: what happens before, between and after the conversation, not just the trace itself.
Once contrastive analysis flags which category is actually broken, the next problem is what watches for it going forward — and at what cost. Turlay’s rule was to start with the most capable model available to prove a task is solvable, then work down. If it can’t be done with a top-tier model, he said, it won’t work with a smaller one. Once a pattern proves viable, teams can sample a fraction of traffic instead of judging every interaction, and move simpler tasks like binary classification to smaller open source models.
LangChain took that further, fine-tuning its own model to detect when a user believes the agent made a mistake, a signal Chase calls perceived error. “The model we fine-tuned was a Qwen model,” he said, referring to Alibaba’s open source family. Combining hand labeling with distillation, the result performed well. “Same as [Claude]Sonnet, for, depending on how we served it, either 10 to 100x cost reduction,” Chase said.
Not every guardrail needs a model. Chase pointed to Claude Code’s own guardrails as proof: regexes, the common programming technique for finding and validating patterns in code. “A lot of the guardrails they had were just regexes,” he said. “They weren’t small LLMs, they were just regexes.”
The bigger question is whether using LLM as a judge removes the need for a human in the loop.
Turlay pointed to accountability, drawing on his prior work at a self-driving car company. His team compressed data intake and retraining into a two-week cycle for shipping a new model to the car. Even then, someone still had to sign off.
“I felt confident on behalf of the company to say this model should go into the car,” he said. The same logic extends to legal, finance and healthcare. “Before we can remove a human to say, I endorse this and I take responsibility legally for it, it’s going to be a while before agents can do that on their own.”
Zhang agreed a human has to remain the guardian on corner cases, even as automation eventually runs at a scale that beats individual human accuracy — machines can see more at the pattern level.
Chase went further: that human check isn’t just a safety net. “Human in the loop is really important for building trust in how these agentic systems work, and also really important for memory and learning from systems,” he said. “There has to be interactions in order for the system to learn.”
Zillow, the real estate technology company, doesn’t get one conversation with its customers. They move from a phone screen to a loan officer to a real estate agent, sometimes over months or years, and expect the context to follow them. A single chatbot could never carry that thread.
At VB Transform 2026, Zillow SVP of Engineering Toby Roberts and Glean co-founder and CEO Arvind Jain described how they built AI architecture meant to carry context across that entire journey — and why context, not raw data, turned out to be the harder problem to solve. Zillow’s products touch roughly 80% of U.S. real estate transactions each year, and the company has been using AI long before ChatGPT existed.
“We pretty quickly identified that we were going to need a persistent context layer that was going to meet our customers and the professionals wherever they were,” Roberts said.
Roberts said Zillow’s AI effort started where most enterprise AI efforts start, with the data itself.
“We started with a large push around making sure our data did have the right foundation,” Roberts said. That meant a data mesh approach, clear data lineage and a governance structure with permissions and identity attached to the data itself.
None of that turned out to be the hard problem. The hard problem was building something that remembered where a customer was in their journey and carried that forward, no matter which surface they showed up on next.
“This context layer has to live to be able to support you where you are at any given point in your journey,” Roberts said. Zillow chose to own that layer itself rather than depend on a single external chat interface, a decision Roberts said the team reached quickly once it looked at the shape of a real transaction rather than a single conversation.
Zillow built its own harness rather than route customers through a single model API. The team drew on 20 years of machine learning history behind products like Zestimate, leaning into smaller, task-specific fine-tuned models instead of one general-purpose model.
Internally, that harness runs alongside Glean. Roberts said Zillow now has thousands of Glean agents in production, handling repetitive tasks with tens of thousands of executions across the company. Glean’s pitch, per Jain, is centralizing that integration work once, through the Glean MCP gateway, rather than letting finance, legal and marketing each rebuild their own connections to the same systems.
That centralization is also a cost lever. Jain pointed to two mechanisms: model routing, which sends most tasks to smaller, cheaper models instead of defaulting to frontier models, and precomputed context, which avoids an agent burning tokens assembling its own context from scratch.
“Claude is also very slow because the first part of assembling that context actually takes forever,” Jain said. Routing that request through Glean instead, he said, can cut token consumption by as much as half.
Across data, cost and permissions, the session offered a few practical takeaways for enterprises building agentic AI on their own systems.
Build the measurement baseline before the AI push, not after. Roberts said Zillow’s ability to credibly attribute a 40% increase in shipped code to AI adoption rests on a DORA metrics baseline the team put in place years earlier, not on the AI rollout itself.
Centralize context once instead of letting every team rebuild it. Jain’s core argument for Glean’s platform is that duplicated integration work across finance, legal and marketing teams is a hidden cost most enterprises haven’t accounted for.
Don’t assume permission inheritance is enough for regulated data. Even with a permissions-aware context platform in place, Zillow layered hard rules and a standing compliance check on top for its most sensitive categories, rather than trusting the architecture to handle it automatically.
Treat context as a cost lever, not just a capability. Model routing and precomputed context were the two mechanisms Jain pointed to for cutting AI spend, both aimed at reducing wasted token consumption rather than adding new capability.
“Models by themselves are not enough to bring automation with AI inside your enterprise,” Jain said. “You do have to connect it with your enterprise context.”
Legacy infrastructure, not the models themselves, is what’s actually slowing AI agents down. That was the shared conclusion of three infrastructure leaders — from LinkedIn, Walmart, and Zendesk — at VB Transform 2026.
The panel brought together Animesh Singh, senior director of AI platform and infrastructure at LinkedIn, Desiree Gosby, SVP of corporate technology services and technology strategy at Walmart, and Sami Ghoche, VP of applied AI at Zendesk, each describing what actually broke when they moved agents from pilot to production. Each arrived at the same conclusion from a different starting point: None of the bottlenecks they hit were model problems.
What tied their answers together was a shared premise: most enterprise infrastructure was built for how humans work, not for how agents work. The gap between those two speeds is where the real engineering happened.
Gosby put it plainly when asked what she’d learned scaling agents inside Walmart’s own workforce. The goal, she said, is to make sure “engineering doesn’t once again become the bottleneck for what it is we’re trying to do.”
Each company hit a different version of the same wall: infrastructure designed for how people work doesn’t hold up once agents are doing the work instead.
At LinkedIn, the first bottleneck wasn’t a model, it was Kubernetes, which assumes containers spin up on demand, a process that takes seconds. Singh said that’s too slow for agents. The fix was moving from on-demand provisioning to pre-provisioned pools of containers that swap agentic workloads in and out in real time.
A second, harder problem surfaced once LinkedIn let agents control their own orchestration. A five-point evaluation system looked clean, but hallucination kept showing up anyway. Singh said the issue was structural, an LLM evaluating another LLM’s output shares the same failure mode as the thing it’s evaluating.
“We built our own harness, our own control flow, and pushed the LLMs to the leaf instead of them orchestrating the loop,” Singh said. Roughly 80% of the workflow is now scripted, deterministic code, with LLMs used only where reasoning is required, and each step’s evidence is committed to disk before the system moves on.
Walmart’s bottleneck came from success. An agent harness put directly into employees’ hands went viral internally, and what Gosby called “citizen developers” began building their own agents to solve problems that once required a formal engineering roadmap. The upside was real innovation. The downside was duplication, dozens of overlapping agents with no coordination. The fix wasn’t reining in the harness, it was building governance to spot duplication, promote the best version of an agent, and get it into production without engineering becoming a chokepoint.
Zendesk hit its bottleneck from the data side. Ghoche, who joined through Zendesk’s acquisition of Forethought, which closed in March 2026, described sitting on what he called a public figure of 20 billion customer conversations in Zendesk’s repository. The instinct is to hand that history to a large language model with a big context window and let it generate the agents a business needs. Ghoche said that doesn’t work. “You can’t really do that, so instead you have to really invest in the underlying data pipelines and all the data infrastructure that comes with that,” he said.
On open source, all three leaders landed on a similar instinct: own what you can, and lean on frontier labs only where they still have a clear edge.
Ghoche said his own view is that most enterprises would prefer to own their models and infrastructure wherever that’s possible, and that reasoning is what drives Zendesk’s own approach. The exception is frontier reasoning work, where the labs still lead, though he said that slice of use cases is shrinking relative to everything else enterprises now do with AI.
LinkedIn’s answer was to build two subsystems specifically for independence. The first is what the company calls an AI gateway, a single interface that every outbound call to a model runs through regardless of provider. The second component is a memory subsystem built to hold context independent of any model provider.
“Every single outbound call going to an LLM, whether it’s on a public cloud or on-prem in our own data centers, follows the same semantics, the same API calls. We can quickly switch between different providers,” Singh said.
Walmart built its own internal gateway to stay vendor agnostic across three workload types: fully deterministic workflows, planner-and-reasoner workflows for open-ended tasks, and a hybrid of the two. Compliance-heavy work stays deterministic by design; governance, security and evaluation run through the gateway regardless of which model is on the other end. Gosby said the choice between a frontier model and an open-weight model comes down to whichever is most effective for the specific workload, not a fixed policy.
Three pieces of advice came up directly, each tied to the wall a leader had already hit.
Invest in evals before anything else. Ghoche called it the thing common to every use case, internal or customer facing.
“The thing that’s common to all of these is evals. It’ll force you to break the problem down, and once you have a robust set of evals, you can move a lot faster,” he said,
Own your agent harness from day one. Gosby’s advice was to put the AI harness directly in employees’ hands early, paired with the infrastructure to monitor what it produces.
“It will unlock a huge amount of innovation,” she said.
Build for model and context independence. Ensuring flexibility is critical for success.
“Build for independence, whether it’s a frontier model of today versus an open source model of tomorrow,” Singh said. “Keep that context within your enterprise so that you can reuse it when you ship the model or the harness tomorrow,” Singh said.
Organizations need to transform to meet the needs of agentic AI.
Meta VP of Engineering Barak Yagour opened his talk at VB Transform 2026 wearing a pair of Ray-Ban Meta AI glasses, a small sign of how far AI has already worked its way into physical life. His argument went further: enterprise infrastructure was built for humans, not for agents, and it’s starting to show.
Yagour, who leads its data infrastructure organization, told the audience that agentic queries hitting Meta’s data systems grew 30x in a single half, an inversion that he said is breaking assumptions the company spent two decades building around.
The shift is not confined to Meta. Automated traffic overtook human traffic on the internet last year, reaching 51% of the total, according to Imperva’s 2025 Bad Bot Report. That traffic is also growing roughly eight times faster than human traffic, according to HUMAN Security’s 2026 State of AI Traffic report. Yagour cited both figures to describe what he called an inflection point already underway inside his own organization.
Yagour framed the shift as an open question for infrastructure teams everywhere. “What happens to the infrastructure we’ve spent years building when agents and not humans become the main consumers of that,” Yagour said. “That’s the world we’re stepping into.”
Yagour said three assumptions are breaking simultaneously inside Meta’s infrastructure: capacity, identity and velocity.
On capacity, the math no longer works the way engineering teams are used to. “One engineer used to mean one unit of load,” he said. “Now one engineer spawns 10 agents, each spawning subagents. Your 1,000-person org can generate the load of 100,000 users practically overnight.”
His answer is not to block agent traffic but to make infrastructure agent-aware, with dynamic controls that understand agent hierarchies, cost attribution that traces consumption back to the use case that spawned it, and throttling that adapts based on priority.
Identity is breaking, too. Yagour said an agent does not fit the categories infrastructure teams built access controls around. It is not a human user, it does not carry a badge and it is not a deployed service, yet it makes decisions on its own.
Velocity is the third assumption under strain. Yagour cited a company-reported figure that GitHub Copilot writes 46% of the average user’s code, then noted that faster code generation does not make the rest of the pipeline faster.
“That code still needs to be built, tested, deployed, monitored,” he said. “The agent writes the code in seconds, but your CI/CD pipeline doesn’t get faster just because the machine is the author.”
Data is where Yagour said the pressure from agents is most direct.
“Data sits at the center of everything,” he said, pointing to the decisions, products, recommender systems and next generation models it drives.
Meta is also rethinking how much autonomy to grant agents inside its own data systems. In February, the company shipped what Yagour called agentic data apps. Within three months, 63% of dashboards published across Meta were built using the new tooling, part of the same 30x rise in agentic queries Yagour cited earlier.
That growth raises a governance question. Human analysts have traditionally sat between raw data and business decisions, curating it and serving as an informal check on quality. Yagour said Meta wants to grant agents more independence on harder problems, but was direct about the risk.
“Autonomy without governance is nothing but chaos,” he said. That’s why the company built what it calls trusted data environments, to preserve the human check as agents take on more of that work.
“Inside, the agent can explore data freely, but every output is traced back to its source and scrutinized. So you always know that the data shared back is trusted and governed,” Yagour said.
Sensitive fields are masked before an agent can reach them, and every access request is evaluated in real time against what the agent is trying to reach, why and whether it is allowed. Yagour summarized the approach as exploring broadly while releasing narrowly.
Meta’s models are also demanding more from data as they shift from correlation to reasoning.
“Reasoning is data hungry,” Yagour said.
Pattern matching works on sparse, summarized signals. Reasoning demands the full behavioral history, every interaction across every surface over time. Yagour pointed to two shifts already underway inside Meta’s infrastructure to keep up.
Real-time streaming is replacing batch ETL for ranking pipelines. A pipeline that takes 24 hours to run is not viable when a model is reasoning about a user’s current intent. Yagour said real-time streaming, not batch extract-transform-load processing, is becoming the backbone of Meta’s ranking and recommendation systems.
Storage is becoming schema-aware to stop GPU starvation. Meta previously stored user data as opaque blobs with no awareness of what the data contained, which Yagour said led to heavy overfetching and idle GPU capacity. The company is now building storage that understands what it holds, pulling only the columns and time ranges a given query needs. Yagour said Meta is building toward 500 million queries per second and a petabyte per second of throughput for training data reads.
That data feeds directly into how Meta’s recommendation systems behave. Yagour said 42% of Instagram users have told the company they want to fundamentally change the algorithm, not adjust a single session or setting. Meta’s response is what Yagour called fully conversational recommendations, where a user tells the system what they want more of and it reasons about intent rather than matching on keywords. Yagour said the same search term, soccer, would return different results for a casual fan looking for highlights than for a club athlete seeking training drills, because the system would reason about which one is asking.
Yagour described the three threads of his talk, agents, data and recommendations, as reinforcing each other rather than moving independently.
“Agents make data more accessible. Better data makes reasoning. Reasoning creates new demands that push agents and infrastructure forward,” he said. “This isn’t linear; it’s a flywheel.”
During the Q&A, an audience member asked whether Meta’s push toward more intelligent infrastructure signals the end of traditional file systems in favor of newer neural storage approaches, and whether agents will keep using SQL as their interface to data the way humans do. Yagour said Meta is experimenting at every level, including questioning whether SQL is the right interface for agents at all, and that storage at Meta’s scale already operates in the multi-digit exabyte range and needs to keep expanding.
Yagour closed his talk with the timeline he believes the industry is working against. “We spent 20 years building infrastructure for humans. We have maybe 20 months to rebuild the whole thing for a world where humans and agents co-create at scale,” Yagour said. “The window is open, but it won’t stay open for long.”
Canva on Tuesday launched Canva Code 2.0, a major upgrade to its AI-powered coding tool that lets users build interactive websites, apps, and experiences using plain-language prompts — and then edit the results as easily as tweaking a Canva presentation. The feature is now available to all of the company’s more than 265 million monthly users across every pricing tier, including free accounts.
The move is Canva’s most aggressive push yet into the fast-growing “vibe coding” market, a category that barely existed 18 months ago but has already minted billion-dollar startups and reshaped how non-developers think about building software. But where rivals like Lovable, Replit, and Bolt.new have focused primarily on generating functional code from text prompts, Canva is making a different bet: that the real bottleneck isn’t creating the code — it’s making the output actually look good.
“Most vibe coding tools stop at functional — generating output that looks the same as everyone else’s,” Canva states in its announcement. “You might get a working prototype, but making it actually look like yours requires a complex editing surface, a separate design tool, a developer, or endless back-and-forth prompting that rarely lands where you want it.”
Danny Wu, Canva’s Head of AI Products, framed the product’s positioning in stark terms during an exclusive interview with VentureBeat ahead of the launch.
“We are deliberately targeting non-technical users,” Wu said. “Canva Code isn’t a tool we’re building for developers. What we’re trying to do is bring the power of AI coding — and really lightweight coding — into the Canva platform, while answering our users’ requests for more interactivity, more customization, and more flexibility, from websites to interactive presentations.”
The update introduces several capabilities designed to collapse the distance between generating code and publishing a polished interactive experience. Users can now create Canva Code projects directly inside other design projects — embedding interactive elements within a whiteboard, presentation deck, or standalone page. Canva has also added more than 50 new templates specifically designed for interactive designs, along with the ability to import raw HTML files from other AI coding tools and convert them into editable Canva designs.
The performance improvements are significant. Canva says it has reduced average code generation time by 75 percent and cut the median time from initial prompt to a published site by 30 percent. The company also reports that integrating Canva Code into the broader Canva editor — allowing users to treat coded outputs like any other design element — has increased active Code users by 25 percent.
Perhaps the most distinctive feature is the editing experience itself. Unlike most AI coding platforms, which require users to re-prompt or modify raw code to make visual changes, Canva Code 2.0 lets users click directly into generated elements to change text, drag and drop images from Canva’s built-in library of over 120 million templates and assets, update colors and fonts through a familiar toolbar, or select a specific element and refine it through conversational AI. Every output is fully interactive and automatically adapts to different screen sizes, with a built-in mobile preview.
Wu demonstrated the drag-and-drop editing during the interview, showing how a generated conference website could be modified in real time — swapping in photos, changing fonts to branded alternatives, and editing text directly on the canvas. “The key differentiator with Canva Code is the editability and the kindness of the outputs it generates,” he said, though he noted one current limitation: “We don’t support moving elements around. You still have to re-prompt for that.”
Canva’s entry into vibe coding at this scale arrives at a pivotal moment for the category. According to market research published by Luminix AI in May 2026, the vibe coding and AI app builder market has reached an estimated $4.7 billion in 2026, with projections pointing toward $12.3 billion by 2027 at roughly 38 percent compound annual growth. The research also estimates that AI-generated code now comprises approximately 41 percent of all code written globally — a figure that would have seemed inconceivable even two years ago.
The competitive landscape has grown ferocious. Lovable, which focuses on conversational, design-forward app generation for non-technical founders, has achieved what may be the fastest revenue ramp in the category’s history — reportedly reaching approximately $400 million in annual recurring revenue by early 2026, according to Luminix’s analysis. Replit, which transformed its browser-based IDE into a full vibe-coding engine through successive AI agent releases, has tripled its valuation to $9 billion and is targeting $1 billion in run-rate revenue by the end of 2026, per the same report. Bolt.new, which runs a full Node.js environment entirely in the browser, scaled from $4 million to $40 million in ARR within months of launching.
And then there is Canva, which brings something none of those platforms possess: a quarter-billion-user design ecosystem where brands, teams, and individuals already store their visual identities, collaborate on projects, and publish content.
Wu positioned Canva Code not as a direct competitor to these developer-focused tools but as something that fills a gap none of them have addressed. “A lot of the requests that we have been getting and the usage we’re seeing is actually with using Canva Code not necessarily as just one artifact, but as part of an overall design, the visual communication they’re trying to tell,” Wu said. “Like when you have a sales deck, you’re able to add a calculator, you’re able to add a visualizer of what exactly your product does. That’s something where an interactive slide can be worth a thousand pictures.”
One of the most strategically interesting features in Canva Code 2.0 is its HTML import capability, which allows users to take code generated by any AI tool — including ChatGPT, Claude, Lovable, or Bolt — and bring it into Canva as a fully editable design. The implication is unmistakable: Canva is positioning itself as the place where AI-generated code gets its finishing touches, regardless of where it was originally created.
When asked directly whether this amounts to positioning Canva as a “finishing layer on top of vibe coding,” Wu offered a diplomatic but revealing response. “It’s really a continuation of our goal to make all design as easy as possible,” he said. “We’ve supported importing PDFs and translating them into docs, importing PowerPoint files — so in one way, it’s an expansion of that. But in another way, it’s really just listening to what our users want and making Canva both the most useful and the most compatible platform.”
He paused, then added: “It’s not that we’re deliberately positioning ourselves as a specific layer, say like a finishing layer after vibe coding. We just really want to make our platform the most accessible and the most pluggable.”
That language — “most pluggable” — suggests a platform strategy that doesn’t require Canva to win the AI code generation race outright. If Canva becomes the default destination for making AI-generated code look professional and on-brand, it captures value from the entire category regardless of which code generation engine users prefer. The strategy also echoes the broader import capabilities that already allow Canva to ingest PowerPoint decks and PDFs from competing platforms, gradually pulling users deeper into the Canva ecosystem without demanding they abandon existing workflows.
Wu was notably candid about the product’s boundaries — a refreshing departure from the typical Silicon Valley product launch. “Canva Code is great for anything that works as a front-end app, and it’s especially good when you want to leverage data, data submissions, and interactivity at small to medium scale,” he said. “I’ll be honest about the limitations. Canva Code is probably not going to be suitable if you’re trying to build a website with complex backends, or if you’re handling hundreds of thousands of visitors per day.”
This candor effectively draws a line between Canva Code and the more ambitious platforms in the space. While Lovable and Replit are pushing toward full-stack application development — complete with databases, authentication, and production-grade hosting — Canva is deliberately limiting its scope to interactive front-end experiences at modest scale. The question is whether that’s a strategic weakness or a disciplined focus. For the teachers, small business owners, and marketing teams that make up the bulk of Canva’s user base, complex backends and high-traffic scalability are irrelevant concerns. What matters is whether they can create an interactive event page, a property listing website, or a classroom hub that looks professional and works on mobile — without hiring a developer or learning a new tool.
When asked about the AI models powering Canva Code, Wu confirmed the company uses a combination of proprietary and third-party models, including those from OpenAI and Anthropic, but declined to specify the exact mix. “We don’t share the exact mix, and it does change over time,” he said. “We also route differently depending on what you’re asking for and which model family we think is best for handling certain requests.”
Canva’s broader AI infrastructure has been significantly bolstered by an acquisition strategy that has accelerated over the past two years. In March 2024, the company acquired Affinity, the British creative software suite popular with Mac users, in a deal that Bloomberg reported was valued at “several hundred million pounds.” Canva at the time positioned the deal as a way to compete with Adobe’s flagship products — Illustrator, Photoshop, and InDesign — by gaining ownership of Affinity’s Designer, Photo, and Publisher applications.
Just four months later, Canva acquired Leonardo.ai, an Australian generative AI startup with over 19 million registered users and more than a billion images generated. Canva co-founder Cameron Adams said at the time that Leonardo.ai’s technology would be integrated into Canva’s Magic Studio generative AI suite.
Together with these acquisitions, Canva Code is the company’s attempt to layer interactive, code-driven capabilities on top of a visual design platform that has already been enhanced by professional-grade design tools and generative AI models. The company reports over 32 billion uses of its AI products to date — a staggering figure that underscores how deeply AI is now woven into everyday Canva workflows, even for users who may not think of themselves as using artificial intelligence.
Canva’s announcement highlights an impressive traction metric: users have created and published more than six million websites using Canva Code since the feature was first introduced a year ago. But the number deserves scrutiny.
Wu clarified in the interview that the six million figure represents published websites over the past year — meaning sites that were either made public or shared via password-protected or private links. “They may have published publicly, or behind a password, or as a private link. But that’s the number of published websites,” he said.
When asked about active retention — how many of those sites are still live and being maintained — Wu acknowledged the gap in his data. This is a meaningful distinction. In the vibe coding market, raw creation numbers can be misleading because the barrier to generating a site is so low. The more telling metric — which Canva does not yet provide — would be how many of those six million sites receive regular traffic or have been updated after initial publication.
The early use cases, however, suggest genuine utility beyond novelty. Educators and school administrators are using Canva Code to build classroom hubs, with one teacher creating bespoke webpages for each of their classrooms to keep students and parents updated on announcements. Small businesses, like Alt Marketing School, have built mini apps for fundraising training and interactive roadmaps for their members. For World Book Day, 50 readers created educational games across different subjects, complete with pedagogical guides for classroom use.
Canva Code 2.0 is available across all of Canva’s pricing tiers, including its free plan — a notable decision given that competitors like Lovable, Bolt, and Replit reserve their most capable features for paid subscribers. “As you go from, say, free to pro to business to enterprise, you would get more AI credits and be able to have higher usage of Canva Code,” Wu said. “But it is available and it is usable — even free Canva accounts as well as education and not-for-profit accounts.”
This credit-based approach mirrors the pricing evolution happening across the entire vibe coding category, where platforms have converged on token or credit systems that meter AI generation capacity rather than gating features behind subscription tiers. The difference is that Canva’s free tier serves as an acquisition funnel for a much larger design platform, not just for the coding feature itself.
For the institutional customers Canva increasingly courts — school districts, real estate brokerages, enterprise marketing teams — data governance is a threshold concern. Wu addressed this directly. “All users and customers have full control over how their data is used,” he said. “They can choose whether their prompts and data are used for AI training in the settings. For businesses and enterprises, team admins can manage this at the organizational level and guarantee that their inputs, content, and outputs won’t be used for training.” This opt-out approach reflects a lesson the broader industry has learned the hard way. As The Verge reported when Canva acquired Leonardo.ai, Adobe suffered significant backlash over a policy update regarding user data and AI model training — a controversy Canva appears keen to avoid.
When asked where Canva Code fits into the company’s long-term trajectory — and whether Canva is building toward a full-stack app development platform — Wu steered the conversation back to the company’s core audience.
“A huge part of it is reducing the gap between your imagination and what’s possible, especially for everyday users — people who don’t have a lot of time,” he said. “They don’t have time to figure out deploys or MCPs or APIs. They just want to design more interactive and more dynamic communication.”
He pointed to the rapid improvement in AI model capabilities as a key accelerant. “The kind of things you can create today in one shot — like a 3D visualization of a solar system — you really couldn’t have trusted the output a year ago. But today, you have a really high success rate.”
Whether Canva Code becomes a durable product category or a feature that gets absorbed into the platform’s broader AI workflow will depend on how quickly the company can close the gap between its current front-end focus and the full-stack capabilities that increasingly define the competition. Lovable is shipping Supabase-backed apps with authentication and databases built in. Replit’s agents can execute autonomous long-running builds. Bolt.new runs entire Node.js environments in a browser tab. These are fundamentally different ambitions than making a conference landing page look good.
But Canva has never won by matching the technical depth of its competitors. A decade ago, it didn’t try to out-feature Adobe — it made design accessible to the 99 percent of people who would never open Photoshop. Now, in a vibe coding market where every tool can generate a working prototype from a prompt, Canva is making the same wager it made in 2012: that for most people, the hardest part was never the building. It was making it look like it came from you.
An enterprise AI agent answers with total confidence, but the number is wrong. Nobody catches it until someone traces it back to a stale metric definition or a document the retrieval system never pulled. The model did not fail. The context it was given did.
In the past six months, 57% of enterprises traced a confident but wrong AI agent answer to missing or inconsistent business context, and 31% said it happened more than once, according to a VB Pulse June 2026 survey of 101 qualified enterprises with more than 100 employees.
The reason is not hard to find. Retrieval over documents is the default way agents get business context for 38% of enterprises, nearly double the next closest approach. The way most enterprises choose a retrieval system compounds the problem. Ease of ingestion and operational simplicity lead the selection criteria, with retrieval accuracy running behind both. The accuracy problem only shows up after the system is already live.
There is a known fix for this, a governed context layer every agent reads from instead of guessing. Vendors are racing to roll out context platforms while most enterprises are still figuring out what it is.
The context layer is meant to be a shared model of what business data actually means, built once and referenced consistently instead of re-derived by every agent that touches it.
The VentureBeat research shows the enterprise response to that idea is broad but unfinished. Twenty-five percent of respondents run one in production. Thirty-four percent are building one right now. The remaining 41% have not started.
Among companies already building or running a governed context layer, 78% report a confident-wrong failure — an AI agent that answered with total certainty and was still wrong. Among companies with no plans to build a layer, only 20% report the same thing. Companies that already got burned are far more likely to be building the fix. Companies that haven’t been burned yet see no urgency.
Every major data and AI platform vendor is now building some version of this layer, and they are not converging on the same architecture.
DataHub is treating catalog metadata and years of analyst query behavior as a knowledge source, then keeping it current as a living system rather than a static wiki.
Microsoft’s Fabric IQ is building a business ontology that any agent, not just Microsoft’s own, can query over MCP.
Couchbase is pushing agent memory and context retrieval down to the edge, arguing the operational database is a more natural home for it than a search or analytics layer bolted on after the fact.
Pinecone’s Nexus is compiling structural logic into the metadata layer ahead of runtime, betting that agents need pre-built structure more than they need faster search.
Snowflake runs a two-layer system, Horizon Context for customer-managed definitions and Cortex Sense for context the platform infers on its own.
Oracle’s Unified Memory Core takes the opposite approach, folding vector, graph and relational data into one transactional engine so there is no sync layer left to go stale.
Google’s Knowledge Catalog mines query logs and usage patterns to curate semantic context automatically.
AWS’s Context service makes the same bet, a knowledge graph that gets smarter from how agents actually use it rather than from manual re-curation.
The vendor approaches differ. What analysts and practitioners have told VentureBeat about the underlying problem, across a run of interviews this year, does not.
When DataHub’s context layer push landed this spring, Constellation Research VP and principal analyst Michael Ni framed the stakes in blunt terms. “Whoever controls runtime context controls the AI decision layer for enterprise data,” Ni said. He was equally direct about how far any single product actually gets a buyer. “Vector memory isn’t business meaning, business meaning isn’t governance and governance isn’t execution,” Ni said.
In the same interview, BARC analyst Kevin Petrie pointed to a narrower but concrete gap. Most context platforms concentrate on structured tables, he said, which give agents trusted facts but miss the harder, messier context locked in documents and unstructured content, exactly the material a business actually runs on day to day.
Stephanie Walter, practice leader for AI Stack at HyperFRAME Research, made a related point earlier this year when VentureBeat asked her about enterprise context fragmentation.
“The market is converging on the same conclusion,” Walter said. “Agents don’t just need more tokens or better models. They need governed, current, low-latency context.” She made a similar case in an earlier review of Pinecone’s Nexus launch, careful not to overstate how new any of this is. Nexus, she said, “shifts knowledge work from runtime chaos to pre-compiled structure. But it’s an evolution of RAG architecture, not a complete reinvention.”
Gartner’s Arun Chandrasekaran, reviewing the same launch, offered the more forward-looking read. Agentic AI, he said, is moving from pure information retrieval toward a reasoning architecture, one where long context works as short-term memory and a vector database functions as deep storage underneath it.
The fragmentation problem shows up hardest at the practitioner level, where separate tools for retrieval, memory and access control were never built to agree with each other. Steven Dickens, CEO and principal analyst at HyperFRAME Research, put it bluntly after Oracle’s AI database push landed this spring. “Data teams are exhausted by fragmentation fatigue,” Dickens said. “Managing a separate vector store, graph database and relational system just to power one agent is a DevOps nightmare.”
Matt Kimball at Moor Insights and Strategy, in that same story, put the production reality more simply. Getting an agent working is not the hard part, he said. The struggle is running it in production, where the goal becomes removing the distance between data and execution rather than adding another layer on top of it.
Here’s what this adds up to for enterprises building on this layer.
Retrieval alone will not close the context gap. RAG is the default source for context in most enterprises today, and it is also the layer most closely associated with the confident-wrong-answer failure. Adding more documents or a bigger index does not fix a definition that is inconsistent across systems.
The semantic context layer is where the budget is actually moving, even where it hasn’t shipped. Fifty-eight percent of enterprises are already engaged — building or in production — but only 25% have actually gotten a layer live. That gap shows where enterprises have decided to spend, not where they’ve arrived.
No single vendor owns the architecture yet, and that is likely to stay true for a while. Enterprises evaluating this layer should expect to integrate rather than pick a single winner, at least for the next several quarters.
The buying decision is happening this year, and it is concentrated among the companies already burned by it. Fifty-seven percent of enterprises plan to switch or add a retrieval or context platform within the next twelve months. That intent is not spread evenly. Enterprises that reported a repeat confident-wrong failure plan to switch or add a provider at roughly 81%, against 32% among enterprises that never hit the problem. The companies shopping for new context tooling right now are largely the ones whose agents already got it wrong.
The agents are already running. The context underneath most of them is still being built, and the vendor selling the fix is being chosen this year.
This data will be part of a broader conversation at VB Transform 2026 on July 14 and 15 in Menlo Park: the context gap enterprises are racing to close, and which of the emerging approaches — governed semantic layers, hybrid retrieval, provider-native bundles — actually holds up in production.
Elon Musk’s SpaceX released Grok 4.5 on Wednesday, the first artificial intelligence model the company has trained specifically for coding and autonomous agents — and the first tangible product of its $60 billion acquisition of the AI coding startup Cursor, completed just weeks ago.
The launch marks a pivotal test of the sprawling, vertically integrated AI empire Musk has assembled over the past six months, and of a strategy that bets developers care less about topping benchmark leaderboards than about speed, cost, and whether a model can actually do the work.
“Announcing Grok 4.5, our first model trained specifically for coding and agents,” the company said in a post on X. “It was trained with Cursor and offers frontier intelligence at leading speeds and cost efficiency.”
SpaceX is not claiming Grok 4.5 is the smartest model in the world. Instead, it is making an economic argument. The company says the model uses half as many tokens per task as comparable models, delivers higher throughput, and costs less than half as much — priced at $2 per million input tokens and $6 per million output tokens. That undercuts the premium tiers of rivals like Anthropic’s Claude Opus line and OpenAI’s frontier models by a wide margin.
Musk framed the positioning candidly. “Our internal assessment is that Grok 4.5 is roughly comparable to Opus 4.7, but much faster,” he wrote on X. “The combination of capability, faster speed and lower cost is what makes it competitive. We are closing the loop on real-world usefulness, not benchmarks. Hardcore engineers at Tesla & SpaceX find Grok 4.5 genuinely useful, which is what actually matters.”
That framing is both a philosophy and a hedge. Independent evaluations released Wednesday suggest Grok 4.5 is genuinely competitive but not dominant on raw capability. The benchmarking firm Artificial Analysis ranked the model fourth on its GDPval-AA v2 index of real-world agentic knowledge work, with an Elo score of 1543, “behind only the latest Claude releases from Anthropic.” But the cost figures are where the model stands out. Artificial Analysis measured Grok 4.5 at $0.49 per completed task — “nearly 90% cheaper than the models ahead of it on our leaderboard,” the firm wrote, placing it “clearly on the Pareto frontier for performance versus cost.”
For enterprise buyers, that math matters enormously. Agentic workloads — where a model works autonomously for minutes or hours, reading codebases, calling tools, and iterating on its own output — consume tokens voraciously. A model that is 90% cheaper per completed task, even if slightly less capable, changes the calculus for any engineering organization deploying agents across hundreds of developers. Investor Gavin Baker captured the market’s cautious optimism: “Pareto dominant for coding by the numbers. We will see on the all-important vibes.”
Grok 4.5 is the first concrete evidence of what SpaceX bought when it acquired Cursor, and the deal itself unfolded in stages. In April, SpaceX struck an unusual arrangement giving it the right to buy the coding startup for $60 billion — or pay billions in fees and compute if it walked away, as Business Insider reported at the time. Days after SpaceX’s record-setting Nasdaq debut in June, the company exercised that right, announcing an all-stock acquisition that CNBC reported is roughly 3.4% dilution at the IPO valuation. SpaceX shares rose 16% on the news.
The strategic logic was always about data as much as product. Cursor’s AI-first code editor generates an enormous stream of high-quality interaction data: how expert engineers write, edit, review, and debug code in real production environments. Musk said openly this spring that Cursor interaction data was being fed directly into Grok’s training. Cursor, for its part, got access to SpaceX’s Colossus supercomputer in Memphis — roughly 200,000 Nvidia GPUs with plans to scale toward one million — after publicly acknowledging it had been “bottlenecked by compute.”
“We’ve partnered with SpaceXAI to train Grok 4.5,” Cursor’s official account posted Wednesday. “It’s our most powerful model yet and the first we’ve built for more than software engineering.” SpaceX says the model reflects that pedigree: it “excels in large codebases and handles long-running tasks that span multiple repositories, hundreds of skills, and a variety of tools” — precisely the messy, multi-file reality of professional software engineering that clean coding benchmarks often fail to capture. Early developer reactions suggest the training paid off. “Ok Grok 4.5 is wild,” posted developer Evan Bacon. “It just built me this rocket tracking app with live data and a 3D globe. I might need a new benchmark after this.”
The polished launch belies how chaotic the road here has been. Grok has spent much of the past year in crisis. In mid-2025, the chatbot generated antisemitic content and at one point called itself “MechaHitler,” episodes covered extensively by NPR and CNN. Earlier this year, its image-generation features allowed users to create sexualized deepfakes, including of children — drawing investigations from the European Commission and Britain’s Ofcom, as the BBC reported, and prompting SpaceX to list the behavior as a business risk in its own IPO filings.
The organization behind the model was fracturing, too. All 11 of Musk’s xAI co-founders had departed by the end of March, according to TechCrunch, and Musk publicly conceded that xAI “was not built right [the] first time around,” saying he was rebuilding it “from the foundations up.” Musk himself admitted at a conference this spring that Grok was “currently behind in coding” — a rare public concession from an executive not known for them.
Against that backdrop, Grok 4.5 reads as the first product of the rebuilt organization — and the first proof point for the audacious story SpaceX told public market investors. During its IPO roadshow, the company pitched a total addressable market of roughly $28 trillion, with about $26 trillion tied to AI, including a $22.7 trillion “enterprise applications” opportunity. Those numbers strained credulity even by Silicon Valley standards. A competitive, cheap coding model is the most direct route from that narrative to actual revenue, which is why Wednesday’s launch carries weight far beyond a routine model release.
The competitive stakes are hard to overstate, because the AI coding market has been consolidating around a single leader — and it isn’t Musk. Even as Cursor’s revenue exploded, its market share was eroding. Spending data from Ramp cited by CNBC showed Cursor’s share of the AI coding category falling from 41% in June 2025 to about 26% by May 2026, while Anthropic came to control roughly half the market. Anthropic also topped CNBC’s Disruptor 50 list this year and, by Artificial Analysis’s own measure, still holds the top spots on agentic performance rankings.
That is the gap Grok 4.5 is engineered to close — not by out-thinking Claude, but by underpricing it. The model’s economics create a classic disruption dynamic: if it delivers most of the frontier’s capability at a fraction of the cost per task, price-sensitive enterprise workloads will migrate, and incumbents will face pressure on their most profitable API traffic. The counterargument is that in coding, quality compounds. A model that resolves a complex bug correctly on the first attempt can be cheaper in practice than one that costs half as much per token but requires three tries. That is why Baker’s caveat about “vibes” — the developer community’s shorthand for a model’s felt reliability on real work — will determine more than any launch-day benchmark.
There is also a structural question buried in the deal. Cursor built its business on offering developers their choice of models, including Claude and GPT. If Grok becomes the favored child inside Cursor — and Musk was already urging users to “Try out Grok 4.5 in Cursor!” within hours of launch — the product risks alienating the very users whose data made Grok 4.5 possible. Regulators, already scrutinizing Grok on safety grounds in two jurisdictions, may take a keen interest in a company that controls the training data, the model, and a dominant distribution channel simultaneously.
Grok 4.5 also crystallizes what Musk’s frenetic dealmaking was building toward. In February, SpaceX absorbed xAI in a share-exchange merger that CNBC confirmed valued the combined company at $1.25 trillion — the largest merger of all time, valuing SpaceX at $1 trillion and xAI at $250 billion. The June IPO followed, the biggest in history, and the stock has since surged past $200 from its $135 offering price, vaulting SpaceX past Amazon and Microsoft to become the fourth most valuable company in the United States.
The result is a single public company that owns nearly the entire stack: Colossus for training compute, ambitions for orbital data centers to power future scaling, a frontier model in Grok, a distribution channel in Cursor’s developer base, and captive demand from Tesla and SpaceX’s own engineering organizations. Neither OpenAI nor Anthropic can fully replicate that integration; both must reach developers through third-party tools, some of which Musk now owns. Whether that concentration proves to be an unassailable moat or a regulatory target — or both — is now one of the defining questions in enterprise AI.
The next few weeks will start to answer it. Artificial Analysis says its full Intelligence Index results are forthcoming. Enterprise pilots will reveal whether the token-efficiency claims survive contact with real codebases. And Anthropic, which has answered every serious challenge this cycle with a rapid counter-release, is unlikely to cede the price-performance frontier quietly.
But the deeper story of Grok 4.5 may be what it says about where the AI race has moved. For three years, the industry’s scoreboard was intelligence: whose model was smartest. Musk, arriving late and battered, has chosen to compete on a different axis entirely — whose model is cheapest to actually use. It is a telling choice from a man who built his fortune not by inventing the rocket or the electric car, but by relentlessly driving down the cost of making them. If the strategy works, Musk will have done to AI what he did to spaceflight. If it doesn’t, he’ll have spent $60 billion to learn that in software, unlike rockets, the cheapest ride isn’t always the one engineers choose.