From Notes to an Agentic Knowledge System: How OKF-Style “Brains” Will Change SEO Execution (and Why SMEs Can’t Ignore It)
Google’s Open Knowledge Format (OKF) points to a near-future where AI agents don’t just read your content—they operate on it. Here’s how to think about OKF-style knowledge systems, how to structure your “business brain,” and how to turn AI-ready knowledge into approved, measurable SEO execution with AYSA.
Search is shifting again—not just in how it ranks pages, but in how information gets discovered, connected, and acted on by software.
Marie Haynes recently described building her own “OKF brain,” a structured personal knowledge system built on Google’s Open Knowledge Format (OKF). The key idea isn’t “markdown is new.” It’s that a shared standard gives AI agents a universal way to interpret knowledge bundles: what a file is, what it references, what it’s connected to, and how it should be used. That’s a big deal for anyone responsible for Search visibility, brand accuracy, and efficient execution.
This editorial is my take—from the perspective of building AYSA.ai and working with real businesses that don’t have time for theory. I’ll break down what OKF signals, what an OKF-style “business brain” looks like in plain English, what can go wrong, and how SMEs and agencies should adapt as we move toward an agentic web.
Concise summary
- OKF is a standard for packaging knowledge so AI agents can read it without custom integration.
- The strategic shift: Your competitive advantage moves from “having content” to “having operational knowledge” that agents can reliably use.
- For SMEs, the win is speed + consistency: repeatable playbooks, fewer missed updates, fewer “tribal knowledge” failures.
- The risk is automation without control: outdated facts, brand/legal errors, and agents making changes without guardrails.
- AYSA’s role: connect Monitoring and AI preparation to Approved Execution—so changes actually ship, safely, and you can measure outcomes.
Key takeaways (for busy operators)
- Standardized knowledge beats scattered documents. If your “source of truth” is spread across Google Docs, emails, and Slack, agents won’t save you—they’ll amplify the mess.
- Structure is leverage. A clean Index, consistent metadata, and explicit links between concepts lets agents answer questions and complete tasks without searching the entire universe of your files.
- Playbooks are where ROI shows up. “Knowledge” is nice. “Do this, then this, then this” is what saves days.
- Execution is the bottleneck. Most companies don’t fail because they lack SEO ideas. They fail because changes don’t get implemented. That’s why approval-first automation matters.
- You don’t need to be a developer. But you do need to treat knowledge like a product: version it, maintain it, and measure its impact.
Table of contents
- What OKF Signals: Search Is Becoming Agentic, Not Just Algorithmic
- Why This Matters Now (Even If You’re Not a “Knowledge Graph Person”)
- The Practical Anatomy of an OKF-Style Business Brain (Without Becoming a Developer)
- The Index File Is the Power Move: Controlling Scope Beats “RAG Everything”
- Choosing Your Core “Types”: Concepts, Entities, References, Systems, Playbooks
- Knowledge Graphs for Grown-Ups: Why Connections Matter More Than Volume
- Ingestion & Maintenance: The Unsexy Work That Makes the System Real
- Playbooks: Turning Expertise Into Repeatable Work (Where Time Savings Actually Come From)
- A Concrete SME Scenario: Multi-Location Clinic vs. AI Answers
- What Can Go Wrong: The Failure Modes of “Agentic SEO”
- The Missing Piece: Turning AI-Ready Knowledge Into Controlled Execution
- What Agencies Should Rethink (Before Their Deliverables Become Commodities)
- A 30-Day Action Plan to Build Your Minimum Viable Business Brain
- What to do next
- Sources and further reading
What OKF Signals: Search Is Becoming Agentic, Not Just Algorithmic
For years, SEO has been framed as a contest between pages and algorithms: publish, optimize, earn links, wait for rankings. That model still matters. But it’s not the whole story anymore.
What OKF represents—at least to me—is a move toward agent-friendly information systems. Not “AI that summarizes your Blog post,” but AI that can:
- Locate a trustworthy source of truth quickly
- Understand what it’s reading (context + metadata)
- Traverse related knowledge (connections)
- Follow procedures (playbooks)
- Trigger actions (updates, audits, change requests)
Marie Haynes’ example of building a personal OKF brain makes this tangible: an agent first reads an index, then knows which files to use, then builds connections, then assists with drafting and operational tasks. Her piece is on Search Engine Journal, and it’s worth reading as a firsthand look at the workflow: Build An OKF Brain Like Mine! (Search Engine Journal).
From a business standpoint, the question isn’t “Should I store notes in markdown?” The question is: When AI agents become normal in search and operations, will they be able to reliably use your knowledge—without you supervising every step?
Why This Matters Now (Even If You’re Not a “Knowledge Graph Person”)
If you run a small or mid-sized business, you might be thinking: “We just need leads/sales. Why should we care about file formats?”
Because the format is a proxy for something bigger:
- Faster change cycles. Google updates documentation and search features constantly. If your team reacts slowly, you lose ground.
- Higher cost of inconsistency. AI answers can surface conflicting info (hours, policies, pricing, services). Inconsistency becomes visible at scale.
- Search is blending with operations. It’s not just “rank a page.” It’s “keep facts accurate,” “resolve duplicates,” “ship structured improvements,” “monitor what AI says.”
OKF is part of a broader trend: making knowledge machine-readable and machine-actionable.
Google Cloud has published an overview on how OKF can improve data sharing (useful to understand the intent behind standardization): Google Cloud: Open Knowledge Format can improve data sharing. The specification is also public in Google Cloud’s knowledge-catalog repository: OKF SPEC.md (GitHub).
When a standard exists, tooling follows. And once tooling exists, businesses that are “AI-ready” operate faster than businesses that aren’t—even if both have the same headcount.
The Practical Anatomy of an OKF-Style Business Brain (Without Becoming a Developer)
Let’s take the mystique out of this.
An OKF-style knowledge system is basically:
- Markdown files for the human-readable content (your knowledge).
- Metadata at the top (often YAML frontmatter) to tell a machine what the file is and how it should be used.
- A clear folder and naming structure so agents can navigate.
- An index file that defines the map and boundaries.
- Links between files so it becomes a connected system, not a dumping ground.
The most important mindset shift: this is not a note-taking system. It’s a decision system. It exists to produce consistent outputs: audits, recommendations, change requests, and drafts that match your business rules.
If you’re a non-technical operator, here’s a helpful framing:
- Entities = “things we sell / locations we serve / products / people / brands.”
- Concepts = “how we think about problems (e.g., Canonicalization, AI Overviews visibility, NAP consistency).”
- References = “authoritative sources we trust and cite.”
- Playbooks = “how we do recurring work.”
- Systems = “how we monitor, ingest, and maintain information.”
The Index File Is the Power Move: Controlling Scope Beats “RAG Everything”
In a lot of AI implementations, teams throw everything into retrieval (RAG) and hope the model figures it out. That’s not strategy—that’s gambling with your own knowledge.
The index approach described in the source context is powerful because it’s a form of scope control:
- Agents start with a map.
- They choose the right domain (e.g., “Local listings accuracy” vs. “On-page product SEO”).
- They retrieve only what they need.
For businesses, this is crucial for two reasons:
- Accuracy: The more irrelevant content you include, the more likely the model mixes contexts and produces plausible nonsense.
- Security and control: You can restrict what an agent can access, which matters if you store sensitive information.
In practice: if your business has multiple lines (ecommerce + local services + B2B), your index should mirror that reality. Agents shouldn’t “free roam” through everything to answer a narrow question.
Choosing Your Core “Types”: Concepts, Entities, References, Systems, Playbooks
Most teams start this backwards. They start by dumping content in a folder called “knowledge.”
Instead, start by defining the types you’ll maintain. You want types that:
- Match how your business operates
- Are stable over time
- Support execution (not just reading)
Here’s a pragmatic set that maps well to search and AI visibility:
1) Entities
Entities are your “facts that must not be wrong,” such as:
- Business name, locations, service areas
- Products, categories, SKUs (for ecommerce)
- Doctors/providers (for clinics), rooms/amenities (for hotels)
- Policies (returns, warranties), pricing rules, shipping thresholds
Why entities matter in AI search: AI answers frequently synthesize factual details. If your facts aren’t consistent across your site and listings, you create ambiguity—exactly the kind that leads to wrong answers.
2) Concepts
Concepts are your reusable interpretations: “what we mean by X” and “how we evaluate Y.” Examples:
- What counts as “thin content” for your brand
- How you decide whether to merge or split service pages
- How you interpret a drop after a Google update
- How you prioritize information gain (original insight vs. repetition)
Concepts keep the team consistent—especially when multiple people (or agents) produce outputs.
3) References
References are your citations: official docs, reputable guides, internal research, policies. The source context includes several primary research leads worth bookmarking:
- Google Cloud blog on OKF
- OKF specification
- Marie Haynes’ OKF page: mariehaynes.com/okf
- Andrej Karpathy’s “LLM Wiki” concept (as referenced in the source context): Karpathy gist
References aren’t just for credibility. They’re for alignment: when the agent generates a recommendation, you want it anchored to sources you trust.
4) Systems
Systems describe the ongoing mechanisms: “how we keep this updated.” Examples:
- Daily checks for documentation changes (if relevant to your niche)
- Monthly audit routines for title tags, schema, internal links
- Local listings sync review
- Content refresh triggers (traffic decay, product changes, seasonality)
A system is what turns a knowledge base into a living asset rather than a dead wiki.
5) Playbooks
Playbooks are procedures agents can execute. They should have:
- Inputs (what data is needed)
- Steps (decision tree / checklist)
- Outputs (what to produce)
- Approval rules (what needs human sign-off)
- Measurement (what to track after execution)
This is where the ROI lives. If you only store concepts and references, you’ve built a library. If you store playbooks, you’ve built an operations engine.
Knowledge Graphs for Grown-Ups: Why Connections Matter More Than Volume
A lot of “AI knowledge management” marketing pushes the idea that more notes = smarter system. That’s wrong in practice.
What matters is:
- Coverage: do you have the right knowledge to answer important questions?
- Consistency: is the knowledge aligned across files?
- Connectivity: can an agent traverse from a symptom to the right playbook, with the right references?
When you connect concepts, entities, and references, you’re essentially building a “map” that reduces hallucination risk and increases speed. The agent doesn’t need to guess what’s relevant; you’ve told it.
But here’s the grown-up truth: the graph visualization is not the point. The point is making the relationships explicit so that:
- New team members ramp faster
- Audits are consistent
- Updates are repeatable
- Decisions are defensible
In SEO, this has an added advantage: search visibility increasingly rewards clarity—clear site architecture, clear topical focus, clear entity signals. An internal knowledge graph can help you design an external web graph.
Ingestion & Maintenance: The Unsexy Work That Makes the System Real
The biggest reason “knowledge systems” fail is simple: nobody maintains them.
Marie’s workflow (as described in the source context) included daily checks for documentation updates and automatic updates to relevant reference files. Whether or not you automate at that level, the underlying principle is right: knowledge decays.
For SMEs, maintenance doesn’t have to be complicated. You can start with rules like:
- Weekly: review top landing pages for accuracy (hours, prices, services, stock status).
- Monthly: check for internal link gaps and content decay signals.
- Quarterly: refresh your top converting pages and your “money” service pages.
- Always: if you change an offer/policy, update the entity file and the affected pages immediately.
And if you do automate ingestion, set boundaries. Automation should propose updates—not silently overwrite your truth.
Playbooks: Turning Expertise Into Repeatable Work (Where Time Savings Actually Come From)
Most businesses don’t need “more SEO ideas.” They need fewer repeated tasks and fewer “starting from scratch” projects.
Playbooks do that. Here are examples that map directly to real-world SEO operations:
Playbook: Local listings & on-site consistency
- Goal: ensure locations, hours, services, and policies match across the website and major listings.
- Inputs: location entity files, website location pages, internal directory listings (if available).
- Outputs: a list of discrepancies + proposed website edits, submitted for approval.
Playbook: Post-update impact analysis
- Goal: after a ranking/traffic shift, quickly diagnose what changed and what to test next.
- Inputs: top page groups, query groups, known site changes, content inventory.
- Outputs: prioritized hypotheses and an execution backlog.
Playbook: On-page SEO refresh
- Goal: keep top pages competitive and accurate.
- Inputs: page intent, conversion goals, entity facts, internal linking targets.
- Outputs: improved headings, FAQs, internal links, schema opportunities, submitted for approval.
Playbook: Content-to-PR packaging
- Goal: turn a strong piece of content into outreach assets (angles, summaries, evidence).
- Inputs: core insight, data sources, target audiences.
- Outputs: pitch variants and landing page requirements.
The point: your “brain” shouldn’t just store what you know—it should store how you work.
A Concrete SME Scenario: Multi-Location Clinic vs. AI Answers
Let’s make this real with a scenario that’s painfully common.
Business: a multi-location dental clinic (say 8–15 locations). The business relies on:
- Local search visibility
- Accurate hours and appointment policies
- Service pages for high-margin procedures
The problem: AI answers (from various assistants) start returning inconsistent details:
- One location is shown as open on Sundays (it’s not)
- Pricing ranges are outdated
- Accepted insurance is inconsistently described
Even if rankings are “fine,” the business loses trust and leads. And the team wastes time arguing about where the wrong info came from.
How an OKF-style brain helps:
- Create entity files for each location: hours, phone, address, services offered, policy notes.
- Create references for what counts as official truth (your internal policy doc; your website pages; your location management system).
- Create a playbook called “Location Accuracy Audit” that checks the website pages for mismatches and produces a change set.
- Create a system that triggers this audit whenever a location entity changes (e.g., holiday hours).
Where AYSA fits: this is exactly where “monitoring + approved execution” matters. The audit is helpful, but the real win is shipping the fixes—without relying on tickets that sit for weeks.
- Use AYSA Monitoring to keep a constant pulse on pages and patterns that impact search visibility.
- Use AYSA to prepare changes (on-page edits, internal links, technical tweaks) aligned to your rules.
- Have a human approve the changes.
- Then let AYSA execute accepted changes on your website—so the work actually gets done.
If you want the broader framing of AI search visibility and what businesses should monitor, start here: AI Search Visibility.
What Can Go Wrong: The Failure Modes of “Agentic SEO”
I’m optimistic about OKF-style standards, but I’m not naive about implementation risk. Here are the biggest failure modes I expect for businesses adopting agentic workflows.
1) Your “brain” becomes a dumping ground
If you don’t define types, scope, and naming, you’ll just create a bigger mess—now with AI-generated mess layered on top.
Fix: start with an index, strict types, and a small set of playbooks tied to revenue outcomes.
2) Outdated references quietly poison outputs
Agents love authoritative-sounding text. If your references are old or contextless, the agent will confidently produce wrong recommendations.
Fix: version references, add “last reviewed” metadata, and build maintenance systems.
3) Over-automation breaks trust (or compliance)
Unapproved edits to medical, financial, legal, or policy pages can create real risk. Even in ecommerce, messing with pricing language or shipping terms can have consequences.
Fix: require approvals for high-risk page types. Build permission tiers.
4) People confuse “answers” with “execution”
This is the biggest operational trap. An agent can produce an SEO audit in minutes. But if nothing ships, the business sees no results. It becomes theater.
Fix: tie every playbook to a queue of approved, measurable changes.
5) You optimize for the agent instead of the customer
As AI answers get more prominent, some brands will write for “citation patterns” rather than customer clarity. That’s a fast path to bland, interchangeable content.
Fix: keep “information gain” (original value) as a standard. Use the agent to help structure, not to remove thinking.
The Missing Piece: Turning AI-Ready Knowledge Into Controlled Execution
This is where my perspective gets sharp.
The internet is full of SEO tools that tell you what to do. There are far fewer systems that help you actually do it—in a safe, auditable way.
In an agentic web, knowledge will be abundant. Execution will be scarce.
That’s why AYSA is built around a simple loop:
- Monitor what matters (site, patterns, visibility signals)
- Prepare changes based on best practices and your business rules
- Ask for approval so humans stay in control
- Execute accepted changes so outcomes are real
If you want to see how we think about AI-assisted SEO tools in practice, start here: AYSA AI SEO Tools. If you’re evaluating whether this fits your stage and budget, you can review pricing.
Now connect the dots: an OKF-style knowledge system is the “brain.” AYSA is the “hands.” The brain is valuable, but hands are how the business makes money.
What Agencies Should Rethink (Before Their Deliverables Become Commodities)
If you run an agency, OKF-style systems are both a threat and an opportunity.
The threat: If your deliverables are audits, content briefs, and recommendations—agents will do a lot of that faster and cheaper.
The opportunity: Agencies that win will productize:
- Client-specific knowledge (entities, constraints, tone, offers)
- Repeatable playbooks (technical audits, content refreshes, local rollouts)
- Execution pipelines (approvals, releases, measurement)
In other words: stop selling PDFs. Start selling outcomes and operational systems.
A practical agency move is to build “client brains” that are scoped and standardized, then use an execution layer that can ship changes quickly. If you want a steady stream of practical execution thinking, the AYSA blog is here: AYSA Blog.
A 30-Day Action Plan to Build Your Minimum Viable Business Brain
Here’s a realistic plan that doesn’t require a platform migration or a six-month knowledge project.
Days 1–3: Define scope and outcomes
- Pick one business objective: local lead growth, ecommerce revenue, demo signups.
- List the top 20 pages that drive that objective.
- Define “must be accurate” facts (hours, policies, pricing rules, services).
Days 4–10: Create your first entity set
- Create entity records for: locations, top products/services, key policies.
- Add simple metadata: owner, last reviewed date, where truth originates.
Days 11–17: Create 5–10 core concepts
- Define how you evaluate on-page quality for your niche.
- Define what “good internal linking” means on your site.
- Define your “do not change without approval” rules.
Days 18–24: Build 2 playbooks that save time immediately
- Playbook #1: “On-page refresh for money pages”
- Playbook #2: “Location/service accuracy audit” (if local) or “Product page accuracy audit” (if ecommerce)
Days 25–30: Connect to execution and measurement
- Set a cadence: weekly review of proposed changes.
- Implement an approval workflow.
- Ship the first batch of changes and document what happened.
This is where AYSA’s model is designed to help: monitor, then prepare, then approve, then execute. The hardest part of SEO is not knowing what to do. It’s getting it done.
What to do next
- Pick one domain (local accuracy, ecommerce product pages, or core service pages) and build a small structured knowledge set—don’t boil the ocean.
- Write two playbooks that remove repeated work and produce a clear output.
- Add guardrails: define what requires human approval and why.
- Choose an execution path so recommendations become live improvements (this is where AYSA’s approval-first execution is a practical fit).
- Review monthly: prune, update references, and improve playbooks based on what actually moved metrics.
Sources and further reading
- Search Engine Journal: Build An OKF Brain Like Mine! (Marie Haynes)
- Google Cloud: How the Open Knowledge Format can improve data sharing
- GoogleCloudPlatform on GitHub: OKF specification
- Andrej Karpathy gist (referenced concept: LLM Wiki idea)
- MarieHaynes.com: OKF resources
Related AYSA resources (internal):
Continue the AI search topic inside AYSA.
Use these pages to connect the article with AI SEO tools, AI visibility monitoring, AI Overviews and approved website execution.
Turn this topic into a website action plan.
Use these AYSA hubs to move from reading to technical fixes, AI visibility monitoring, research, glossary context and approval-first SEO execution.
