Two teams ask an AI agent for last quarter’s net revenue retention, receive two different numbers, and both results arrive stamped with confident explanations that sound right but do not agree. That is the moment dashboards stop being helpful, workflows stall, and trust in automation cracks—because the system did not just answer poorly, it reasoned from shifting ground.
The trust gap grows sharper when agents are asked to act, not chat. Routing a discount approval, filing a support escalation, or drafting a supply plan requires consistent definitions, guardrails, and an audit trail. “Good enough” bots trained on raw or loosely governed data tend to improvise, which works for demos and breaks in production. The question for enterprises now is not whether agents can talk, but whether they can be relied on to decide and do.
Why This Story Matters: From Chat to Action
Agentic AI moved center stage as leaders looked for systems that plan, use tools, and execute inside real workflows. That shift changed the selection criteria. Governance, reuse, and context now outweigh flashy novelty. Programs succeed when agents inherit the organization’s definitions, permissions, and policies—precisely the assets many analytics stacks already maintain but rarely expose to AI.
Production is where many AI efforts falter. Scattered data estates and unclear ownership produce drifting definitions; missing access controls and patchy auditability stall rollouts. These problems are not model issues, they are context and governance gaps. The market responded with frameworks from data platforms and analytics vendors, racing to operationalize agents with reliability at the core.
GoodData stepped into this race with Agent Builder, positioning it not as a generic toolkit but as governed infrastructure for data-grounded agents. The bet is straightforward: reuse a mature semantic layer and a policy-aware context layer so agents can answer and act with the same consistency that business intelligence has enforced for years—only now inside workflows instead of just on dashboards.
Inside the Play: Semantics and Context as Infrastructure
At the heart of GoodData’s approach sits the semantic layer: durable metric definitions, logical data models, and permissioning refined across long-running enterprise deployments. Binding agent behavior to that layer reduces drift because the agent does not invent “gross margin” anew; it calls the definition the company already trusts. When multiple agents consult the same semantics, conflicting outputs drop and reproducibility rises.
The second pillar is a context layer that spans structured and unstructured data while honoring policy. Rather than scraping content ad hoc, Agent Builder organizes knowledge with auditability and predictability, then feeds it to agents through retrieval that is aware of roles, scopes, and compliance rules. Two specialized services—AI Memory for rules, terms, and preferences, and AI Knowledge for domain context—aim to keep reasoning relevant and consistent across tasks.
Framed this way, semantics and context act like runtime infrastructure, not documentation. Decisions inherit definitions, and actions inherit permissions. The result is less about answering questions and more about executing governed steps, whether that means selecting a forecast method, choosing a data source under least-privilege constraints, or sequencing tools to resolve a ticket with traceable rationale.
On the Ground: Product, Governance, and Delivery
Agent Builder focuses on analytics-informed workflows rather than open-ended chit-chat. Development spans no-code setup for quick starts, code-first APIs for customization, and templates for common patterns. Under the hood, the planning and execution framework supports structured reasoning: agents break down tasks, select tools, and adapt steps within defined guardrails, so improvisation yields to policy-aligned strategy.
Observability is woven into operations with tracing, performance monitoring, and usage analytics. Administrators can examine how an agent chose a path, where it sourced context, and how long each step took—data that informs tuning and compliance reviews. This visibility is crucial when multiple agents collaborate or when outcomes affect customers and revenue.
Governance-by-design makes administrators the primary owners. Central control of roles, skills, knowledge domains, and permissions ensures least-privilege access carries through tenants and teams. Audit trails provide a ledger of changes and actions, and approval workflows gate updates to agent behavior. The posture is clear: safer by default, with scale as a feature of governance rather than an obstacle to it.
Competitive Picture: Strengths, Limits, and Signals
The competitive arena is crowded. Data platforms like Databricks and Snowflake, hyperscalers, and analytics vendors such as Domo and Qlik all offer agent frameworks or patterns. GoodData’s differentiation centers on its mature semantic layer and a context layer that enforces predictability at inference time. That maturity can matter when moving from pilots to production, where consistency often outweighs breadth of integrations.
For independent software vendors and multi-tenant enterprises, delivery model and economics are part of the calculus. GoodData’s track record in embedded analytics, combined with per-workspace pricing and unlimited users, suits large surface areas where per-seat licensing strains budgets. Build-once, deploy-across-tenant patterns become feasible when semantics and access rules travel with the agent.
Constraints remain. Data quality and freshness stay upstream responsibilities; Agent Builder consumes and governs context but does not remediate source data. Building non-trivial agents still requires expertise. And while developer-facing traces exist, broader end-user transparency—clear “why” views without console spelunking—has room to improve. The roadmap points toward more prebuilt agents, deeper customization, and greater transparency embedded in everyday apps.
Expert Voices: Reuse, Embedded Scale, and Transparency
Michael Ni of Constellation Research emphasized speed and reuse through semantics: “Turning existing semantic assets into agents collapses build time and reduces guesswork. Tight coupling between agent behavior and the semantic layer narrows unguided outputs that plague less-governed stacks.” His point underscored the strategic value of repurposing BI foundations as operational scaffolding for agents.
Mike Leone at Moor Insights & Strategy highlighted embedded strength and economics: “An ISV that already trusts GoodData’s access controls and metric definitions gains a head start. Per-workspace pricing aligns with scale deployments where per-user models can spiral.” He also issued a callout: “Provenance and reasoning need to be transparent for non-developers, or trust stalls at the last mile.”
Rosta Striz of GoodData framed the product’s purpose-built stance: “Agent Builder grew out of enterprise projects that demanded grounding, relevance, and data quality. It is governed infrastructure, not a generic kit.” Practitioners echo the consensus: trustworthy agents require governed context, not raw data sprawl; best fit emerges for existing GoodData users and ISVs; and development complexity persists even as governance reduces risk.
What Comes Next: A Practical Path Toward Trustworthy Agents
Enterprises that aimed to move from chat to action needed a trust stack, and the pieces were available to assemble. First, codify metrics, policies, and lineage in a semantic backbone so definitions travel with every agent. Next, build context services—memory, knowledge, and retrieval—with auditability to keep reasoning tied to business reality. Then, enforce execution guardrails for planning and tool orchestration. Finally, expose observability and user-facing transparency so outcomes can be explained, repeated, and improved.
For ISVs and multi-tenant teams, the immediate playbook was to template domain agents once, parameterize tenant semantics without forking code, and centralize monitoring for drift, usage, and cost. On the data side, leaders validated freshness SLAs, shored up contracts in the warehouse, mapped sensitive fields to access policies, and red-teamed agents for unsafe actions or hallucinated metrics before broad rollout.
In practice, the organizations that moved fastest selected concrete KPIs—semantic adherence rate, policy violation rate, and reproducibility—and instrumented both agent traces and end-user “why” views. When paired with solid data hygiene, GoodData’s Agent Builder provided governed context at decision time, enabling faster, safer deployments in embedded and multi-tenant settings where reuse and control matter most.
