Transcript
00:00:00You've probably heard all the hype around second brains and Claude OS.
00:00:03People have been using Claude code to set up their entire systems,
00:00:07running it like an operating system instead of just a coding agent.
00:00:10But these systems come with their own problems.
00:00:12When someone sets up a second brain, they build it for their own use
00:00:16and structure it the way they think works best.
00:00:18There's no standard way of doing it,
00:00:20which makes these systems hard to navigate and keeps them from being shareable.
00:00:23To solve this, Google just released the Open Knowledge format,
00:00:26where Google is giving their own way on how to build such operating systems with AI.
00:00:31If this is your first time here, we're a software company and this is our channel AI Labs,
00:00:36where we show you how to optimize your own processes with AI the same way we've done with ours.
00:00:41And in this video, we're going to tell you what this format is,
00:00:44how it solves the problem and why it actually matters for your workflows.
00:00:48But before we get into what Google did, let's first understand the real issue.
00:00:52In our previous videos, we've talked about maintaining a second brain
00:00:55and we manage one for ourselves too, where we keep all our strategies, research and guidelines.
00:01:00It's version controlled with Git and push to GitHub and everyone on our team has access to it.
00:01:05So whenever new people join us, they can just pull it and get context on how we work.
00:01:09And like we mentioned before, this second brain is controlled by a Claude.md file.
00:01:13That file basically guides the agent on how to navigate around the brain.
00:01:17We've also got dedicated Claude.md files in each folder,
00:01:20so the agent has specific instructions for working in that directory.
00:01:24But even though Claude is pretty good at getting context from files, it still messes up a lot.
00:01:28It happened to us so many times where it would put a file in the wrong place
00:01:31and then we'd have to remind it where it actually goes.
00:01:34And after that, it would just create a new folder for it,
00:01:37simply because it doesn't know similar info already exists in another folder under a different name.
00:01:41The real problem is that Claude doesn't know the info it needs already exists in the knowledge base.
00:01:47It only finds things when it actively searches for them.
00:01:49So unless you tell it to look in a certain file, it won't even know that file is there.
00:01:53This isn't really obvious in smaller knowledge bases,
00:01:56but it becomes a lot more visible once you're working with a big one.
00:01:59The way Claude searches is by matching keywords against the file content
00:02:03and it uses the file names as a guide too.
00:02:05So if you ask it to search through a really nested folder structure,
00:02:08it has to make a bunch of attempts before it lands on the right file.
00:02:12This not only wastes time, but it consumes a lot of tokens as well.
00:02:15So Google just launched open knowledge format and the problem it fixes is standardization.
00:02:20And this is something we've already seen happen across agents a bunch of times.
00:02:24When there was a need to let agents talk to external resources beyond what they had in the terminal,
00:02:29they introduced MCPs and it became a protocol that every agent adopted.
00:02:33In the same way, packaging reusable instructions came in the form of skills
00:02:36and just like MCPs, they spread across every agent.
00:02:40And when there was a need to standardize how you communicate design intent,
00:02:43Google launched the design.md standard too.
00:02:46So just like there's always a need to standardize things,
00:02:49there was a need to standardize knowledge too.
00:02:51And that's exactly what open knowledge format does.
00:02:53Now this idea isn't really new.
00:02:55It's based on the LLM wiki pattern which Andre Karpathy came up with
00:02:58and it got really popular a while ago.
00:03:00Before he came up with this, people were relying on the RAG approach
00:03:03where you convert all your huge documents into vector format.
00:03:07And vectors do help because they basically put everything into a form that models can understand.
00:03:12From there, the system matches the meaning of your query against the existing data
00:03:15and returns the most relevant matches.
00:03:18But Karpathy pointed out that this causes issues.
00:03:20Whenever you ask a question, the agent is basically rebuilding the information from scratch.
00:03:25It hands you an answer, but it's not building up any knowledge over time.
00:03:28So he suggested using markdown files to build knowledge bases instead
00:03:31because that way the agent can actually gather context as it goes.
00:03:35His approach used a model's ability to navigate a file system.
00:03:38And after he shared the idea, a lot of people started building second brains of their own.
00:03:43But the problem was that each one was designed around its creator's personal workflow.
00:03:47The person who organized it knew what was in each folder
00:03:50and could navigate it easily with the agent.
00:03:52But a new person would have a hard time
00:03:54because they'd have to spend time letting the agent explore the folders
00:03:57and figure out what the knowledge base actually holds.
00:04:01OKF solves this by creating a standard way of organizing files
00:04:04so that not just an agent but a human can also understand what's inside the knowledge base.
00:04:09It makes knowledge shareable by packaging it into a bundle.
00:04:12And this bundle can contain markdown files
00:04:14which hold the actual information about whatever you're building the knowledge base for.
00:04:18Each file also includes YAML frontmata which is basically a small block at the top of the file
00:04:23that describes what's inside it so the agent knows what that file holds.
00:04:27So OKF doesn't really introduce anything new.
00:04:29Instead it gives you a standard format that anyone can produce and read
00:04:32and it makes knowledge portable across different systems.
00:04:35When we first heard about it and went through it, one thought came to mind.
00:04:39Since Google is trying to turn web search into agentic search,
00:04:42this could also be an attempt to support that shift.
00:04:44Right now, websites are adding LLMs.txt files
00:04:48because they hold information about the website that's specifically tailored for models
00:04:52and that gives those agentic systems context about the site.
00:04:55So instead of relying only on LLMs.txt,
00:04:58websites might eventually start adding OKF bundles too.
00:05:01That would let agents query their content more efficiently
00:05:04and maybe give better search results based on that structured info.
00:05:07Right now, it's only meant for internal use
00:05:09but this is something that could end up happening.
00:05:12So to understand how it helps, let's see how OKF works under the hood.
00:05:16This system takes everything that's a part of your knowledge base
00:05:18and represents it as objects called concepts.
00:05:21It could be your data, markdown documents, YAML files
00:05:24or literally anything else that goes into it.
00:05:26The structure works like this.
00:05:28All the information you want to organize gets placed inside folders
00:05:31named after the topic
00:05:32and each one only holds content about that one topic
00:05:35and within every folder, there's an index.md file.
00:05:38This one's the most important because it's what the agent reads first.
00:05:41It gives the agent context on what's inside that folder.
00:05:44Each concept document has a small YAML block
00:05:46that includes a name and a description
00:05:48that lets the agent know exactly what it is
00:05:50and what's inside the document
00:05:52and just like skills have a similar YAML block,
00:05:54this serves the exact same purpose.
00:05:56It feeds the agent context bit by bit
00:05:58so it only loads the exact thing it needs
00:06:00by reading these descriptions first
00:06:02and then pulling in the relevant content.
00:06:04The main principle OKF is built on is minimalism.
00:06:07The idea is that each concept should represent only one thing
00:06:09and the type field inside the document tells you what that thing is.
00:06:13It shouldn't hold multiple unrelated things
00:06:15because the moment a concept mixes topics,
00:06:17the agent loses the ability to load the exact information it needs.
00:06:21Another principle of OKF
00:06:22is separating the knowledge base from whoever's consuming it.
00:06:25Whether it's an agent, a human, a team member or anything else,
00:06:29the knowledge itself stays independent.
00:06:31It's not also tied to any specific platform
00:06:33which is what makes it usable with pretty much anything.
00:06:36But before we see this system in action,
00:06:38let's have a word by our sponsor, Mobbin.
00:06:40If you've used tools like Cursor, Lovable or Claude Code to build a UI,
00:06:44you've probably noticed they all spit out the same thing,
00:06:47the same hero section, card layout and same generic onboarding.
00:06:50It looks like AI slop and the reason is simple.
00:06:53These tools have never actually seen what good design looks like,
00:06:56but Mobbin has.
00:06:57Mobbin just launched an MCP server
00:06:59that connects your AI tools directly to their library
00:07:02of over 621,000 real app screens
00:07:05and 142,000 flows from shipped products like Revolut, Uber and Wise.
00:07:11So here's how I used it.
00:07:12I was building a checkout flow
00:07:13and asked my agent to reference how the best apps handle it.
00:07:16The key part, it's not copying screens.
00:07:18Mobbin gives the agent the real flows,
00:07:21states and hierarchy behind those designs before it writes any code
00:07:24so it builds from proven patterns instead of guessing.
00:07:27Setup takes under a minute and it works across Claude, Cursor, V0 and more.
00:07:31Try Mobbin MCP using the link in the pinned comment.
00:07:34So we wanted to see how this system actually performs in a real setup
00:07:38and since we were already maintaining a second brain
00:07:41that's shared across our team through GitHub,
00:07:43we tested OKF on it.
00:07:44But we didn't want to touch the main branch in case it didn't work out.
00:07:47So we created a new branch which is basically a separate copy of the project
00:07:51and made all our changes there.
00:07:52So OKF basically ships with three things.
00:07:55The first one is an enrichment agent.
00:07:57It takes the data that's sitting in BigQuery
00:07:59which is basically Google's big database for storing data,
00:08:03converts it into OKF concept documents
00:08:05and then runs an LLM pass to check them.
00:08:07Then there's an HTML visualization tool
00:08:09that turns an OKF bundle into an interactive graph view
00:08:13that's easier to explore.
00:08:14And it comes with examples of what properly formatted OKF data
00:08:18should look like which the agent can use as a reference.
00:08:20Now since we weren't working with BigQuery,
00:08:22we didn't need that first part.
00:08:24It would have needed setting up a whole project around it on Google Cloud
00:08:27which we didn't need since our project was already tracked with Git.
00:08:31But the tool it ships with for turning data into the OKF format
00:08:34is designed only for BigQuery.
00:08:36So as a workaround, we created a skill called Markdown to OKF.
00:08:39What this skill does is convert any folder of Markdown files
00:08:42into an open knowledge format bundle following the spec.
00:08:45And the way it's designed, code does most of the work.
00:08:47Only a small part is handled by an agent for the judgment-based stuff.
00:08:51It follows a script-first approach.
00:08:53And that's because doing the work through code
00:08:55puts less load on the agent and uses fewer tokens.
00:08:58The skill has a script that converts Markdown into the OKF format.
00:09:02It also includes evals to test the conversion so it performs reliably.
00:09:06And these evals are basically prompts that the agent runs against the output
00:09:09to make sure everything was converted correctly.
00:09:12So we then switched to our new branch and asked it to do the conversion.
00:09:15It ran all the scripts and converted the files using the instructions.
00:09:19And this created an index.md file with links to all the subfolders by referencing them.
00:09:24If you've used Obsidian before, you'll know this is really similar to how it connects different pages.
00:09:29And this is also what Obsidian uses to build its graph view.
00:09:32And the index.md doesn't just exist at the root level.
00:09:35It also exists inside each subfolder.
00:09:37Each one lists everything inside that folder.
00:09:40So the agent knows what content is available there.
00:09:42Now like we mentioned, OKF ships with a visualization tool.
00:09:45So we ran it on our bundle using the visualize command in the terminal.
00:09:49And it generated an HTML document representing the entire knowledge base.
00:09:53And you can just open it in a browser.
00:09:55It lays out all the nodes along with the connections between files.
00:09:58Which gives you an interactive way of understanding the whole system and how everything connects.
00:10:03So with all our documents converted into the OKF structure, we tested how it performed when searching.
00:10:07But when we first asked it to look for a file, it just defaulted to the way it normally searches by matching patterns.
00:10:13And that's because OKF isn't a widely adopted standard yet and only came out recently, so Claude didn't really know it existed.
00:10:20To fix that, we added a section in the Claude.md file explaining how to navigate the system, what role each file plays, and how the structure should be used.
00:10:28Once that was in place, we asked it to navigate to a certain file, and this time it started going through the index.md files we'd created, and it was able to give results way faster than searching through the entire knowledge base, the way Claude would normally do here.
00:10:42It also used fewer tokens because it loaded the YAML metadata first, so it got an understanding of what each file held before deciding whether it actually needed to open it.
00:10:50So the main advantages you'll get are two things, lower token usage and faster retrieval times.
00:10:56It really is a quicker way to pull information with less chance of the errors we talked about earlier, and because the structure is documented in the Claude.md file, it won't forget where files belong.
00:11:05On top of that, it knows what each file does, because it's spelled out in the index.md files.
00:11:10Right now, models are already pretty capable on their own with pattern matching and running their own terminal commands.
00:11:16So until it becomes an open standard that agents support out of the box, this is more of an optimization than something you really need.
00:11:23Now, the skills we created can be found in AI Labs Pro, which is our community.
00:11:27That's where you'll get the resources, the starter packs, and more, along with a place to interact with a bunch of like-minded nerds, including our team.
00:11:34So if you've found value in what we do and want to support the channel, this is the best way to do it.
00:11:39The link's in the description.
00:11:40That brings us to the end of this video.
00:11:42If you'd like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below.
00:11:49As always, thank you for watching, and I'll see you in the next one.