AI Agents Don't Just Need Tools. They Need Knowledge They Can Trust
AI Agents Don't Just Need Tools. They Need Knowledge They Can Trust.
Why Google’s Open Knowledge Format (OKF) v0.2 is quietly solving AI’s biggest enterprise bottleneck.
The AI industry has spent the last two years obsessing over models. We endlessly debate which model is smarter, which is faster, which has better reasoning, and which costs less per million tokens.
Those questions still matter, but a more fundamental—and arguably boring—problem is quickly emerging as the true bottleneck for enterprise AI: What does an agent actually know about the system it is operating in?
If you give an agent access to your database, it can query it. Give it an API, and it can call it. Give it a Model Context Protocol (MCP) server, and it can discover tools. But what tells the agent that revenue means recognized revenue rather than money received? What tells it which database table is deprecated, which runbook to follow during an incident, or which metric has actually been reviewed by a human?
Most importantly: can the agent trust the answer it just found?
This is where Google's Open Knowledge Format (OKF) gets interesting.
From AI Assistants to Autonomous Agents
The market is clearly pushing beyond chatbots. Gartner predicted that up to 40% of enterprise applications would include task-specific AI agents by the end of 2026, compared with less than 5% in 2025.
That is a significant shift. An assistant waits for you to ask something. An agent, however, can understand a goal, find required information, select tools, execute actions, check the result, and continue working.
This entirely changes the infrastructure problem. When AI was primarily generating text, bad context usually just meant a bad answer. But when AI starts taking actions, bad context can mean a broken production deployment, a wrong financial calculation, or a halted operational workflow. Suddenly, knowledge quality becomes an infrastructure concern.
The industry is already building the pieces to support this. Anthropic’s MCP helps agents connect to tools and data. Google’s Agent2Agent (A2A) work focuses on inter-agent communication (which Microsoft has publicly backed). Google also introduced Agentic Resource Discovery in 2026 to help agents discover and verify tools across the web.
Notice the pattern? Tools. Agents. Discovery. Communication.
The next missing piece of the stack is knowledge.
What is the Open Knowledge Format?
Google introduced the Open Knowledge Format in June 2026 with a surprisingly simple premise. Instead of locking organizational knowledge inside a proprietary AI platform, represent it using ordinary files: Markdown, YAML frontmatter, directories, and links between documents.
An OKF bundle can describe databases, tables, APIs, business definitions, metrics, and runbooks. The important part isn't that Markdown is revolutionary—it isn't. That is exactly the point.
Google’s argument is that knowledge should be portable and interoperable. If an engineer can open the file, an agent can consume it. If Git can store it, your infrastructure team can version it. If another company wants to consume it, they don't need your proprietary SDK. It’s a stark departure from the philosophy of building another giant, monolithic knowledge platform.
The Four-Letter Problem: Trust
The first version of OKF established this basic format, but it left an obvious gap. Imagine an AI agent generates 10,000 knowledge documents overnight. You now have 10,000 pieces of machine-generated knowledge. But why should anyone—or any agent—trust them?
This is the problem OKF v0.2 tries to address. The July 2026 release adds optional trust and provenance information to the format.
---
type: Metric
title: Revenue
generated:
by: finance-agent
at: 2026-08-31T14:00:00Z
verified:
- by: human:finance-team
at: 2026-09-01T09:30:00Z
---Now, an agent doesn't just know what a metric is. It knows who generated it, when it was generated, and whether a human or a machine was responsible for verifying it.
It looks like standard metadata, but it is metadata with teeth. Imagine an agent has two definitions for the same metric: one generated yesterday by another agent, and one reviewed by the finance team. A human might instinctively pick the second one. An autonomous agent doesn't have that instinct—it needs a signal.
OKF v0.2 introduces these signals through generated and verified fields. Google describes these trust tiers as advisory rather than access controls. OKF isn't saying "this information is true." It is saying, "here is information about how this information was produced and verified."
Trust becomes something a downstream system can actually reason about:
Executive Agent
|
v
Only use human-reviewed metrics
|
v
OKF knowledge bundle
|
+--> Revenue — human reviewed
+--> Churn — human reviewed
+--> Experimental KPI — machine confirmed
+--> Unknown metric — unverifiedThe agent no longer has to blindly trust everything. It can make decisions based on provenance.
Why Not Just Use a Vector Database?
Because embeddings don't solve everything. Vector search is great at finding things that are semantically similar, but it doesn't automatically tell you whether information is authoritative, who owns it, whether it's current, or what relationships exist between concepts.
You can absolutely build all of that logic around a vector database, and companies will. But doing so usually results in yet another proprietary representation of knowledge.
OKF takes the opposite approach: keep the source knowledge boring, and put the intelligence around it. That is a surprisingly powerful architectural decision.
The Emerging Agent Stack
The AI market is starting to look less like a single LLM API and more like a distributed ecosystem:
┌──────────────┐
│ Agents │
└──────┬───────┘
│
┌────────────┼────────────┐
│ │ │
v v v
Tools Other Knowledge
/ MCP Agents / OKF
│ │ │
└────────────┼────────────┘
│
v
Enterprise SystemsMCP connects agents to capabilities. A2A helps them communicate. Agentic Resource Discovery handles finding capabilities. OKF addresses the knowledge and context layer. These aren't competing technologies; they are complementary pieces of an agent ecosystem.
Real-World Stakes: Agentic Commerce
This isn't just a Silicon Valley infrastructure story. In September 2026, Reuters reported that India is preparing a framework allowing AI agents to conduct small UPI payments without requiring approval for every individual transaction. The proposed approach includes spending limits, identity checks, and delegated payment controls.
That is a massive conceptual jump. An agent that recommends something is one thing; an agent that actually spends money is another. Once agents can transact, context, authorization, provenance, and trust stop being nice-to-have features. They become infrastructure.
If an agent is allowed to spend ₹5,000 on behalf of a user, the system needs to know:
- What is the agent allowed to buy?
- Who authorized it?
- Which policy version was active?
- Was the information it used trustworthy?
This is where standards around knowledge and trust stop looking academic and start looking essential.
The Uncomfortable Part: OKF Isn't Magic
There is a temptation with every new AI standard to think, "Cool, problem solved." OKF doesn't magically make knowledge correct. It doesn't prevent an agent from hallucinating, solve authorization, or replace observability and data catalogs.
The value is more fundamental: it gives different systems a common language for representing knowledge.
The next phase of enterprise AI won't be won purely by whoever has the smartest model. It will be won by whoever can give agents the right context at the right time, with enough evidence to trust it.
The clever thing about OKF is that it isn't trying to be clever. The specification remains intentionally minimal: Markdown files with YAML frontmatter, without requiring a central registry, proprietary runtime, or mandatory SDK.
As agents become more autonomous, "here's some context" isn't enough anymore. We need to know where that context came from, when it was updated, who verified it, and whether an agent should actually trust it. The future of agentic AI might look incredibly futuristic from the outside, but underneath? It will likely be built on something wonderfully boring: files, metadata, links, version control, and very careful engineering.
And honestly, that's probably how it should be.
Sources
- Google Cloud: Open Knowledge Format introduction and v0.1 design.
- Google Cloud: OKF v0.2 and trust/provenance signals.
- Google Cloud: Scaling OKF with Knowledge Catalog.
- Google Cloud: Open Knowledge Format v0.2 specification.
- Google Developers Blog: Agentic Resource Discovery specification.
- Gartner: Enterprise adoption forecast for task-specific AI agents.
- Reuters: India's emerging framework for agentic UPI payments.