Edoardo Chiò

@Franc0Fernand0 Interesting take, I agree that being a jack of all trades is useful in new, greenfield projects, but often a deeply proficient engineer is the one able to carry on the most challenging tasks when it comes to a specific product. Maybe things are changing now with coding agents.

The best engineers I've met all shared one trait: They knew a little about a lot of things. Not experts in everything, but they had working mental models of databases, protocols, design choices, and how different systems solve problems. This kind of breadth didn't come from their day job. They were always interested in new things, so they read articles, watched talks, and looked into interesting topics when it wasn't related to their current work. The payoff is huge. When you've seen how a lot of different systems solve their problems, you start drawing parallels and connecting dots other people can't. That's where out-of-the-box solutions actually come from. And it doesn't take all your weekends. 30 minutes every weekday, on something you genuinely find interesting, is enough to become a much better engineer. The hard part isn't the time. It's the consistency. But once it becomes a habit, complex topics stop feeling intimidating, and you find yourself navigating the whole landscape with ease.

@mem0ai If anyone is interested on a deterministic approach to manage LLM wikis locally, focused on markdown frontmatter validation, have a look at CLI I've developed in rust github.com/edochi/mdvs

@dreamsofcode_io But is this garbage collection? I'm not an expert, but it doesn't look like GC

I read this issue earlier this morning and kinda feel sympathetic towards Andrew. Bun’s rewrite to Rust has obviously impacted him (hence the “unlike Rust” comment). Whilst that part is petty, it does seem to be driving him to find a solution for Zig. Personally, I don’t think garbage collection is the right solution (1-6x perf impact), but even still, the fact he’s searching for one to improve Zig following one of its biggest negative events is commendable imho. Either way, will be interesting to see where he lands.

@hwchase17 If anybody's interested, I created a CLI to infer and validate markdown frontmatter fields, and then perform hybrid search filtered on those. Compatible with OKF, whatever is the structure of the wiki. Fully open source github.com/edochi/mdvs

there needs to be an OPEN standard for memory OKF (Open Knowledge Format) is one such standard excited to announce that we're now using it in OpenWiki

Today, we’re announcing Bonsai 27B: the first 27B-class model to run on a phone. Bonsai 27B is the new multimodal flagship of the Bonsai family. Based on Qwen3.6 27B, it brings a new capability tier to local AI: multi-step reasoning, structured tool use, long-context workflows, and coherent agentic loops. Until now, models in this class have been impractical to deploy locally. A 27B model occupies roughly 54 GB in 16-bit precision, and even a strong 4-bit build is around 18GB - too large for a phone and for most laptops. Bonsai 27B changes that. It comes in two variants: • Ternary Bonsai 27B: 5.9 GB, 1.71 effective bits per weight, optimized for laptop-class quality. • 1-bit Bonsai 27B: 3.9 GB, 1.125 effective bits per weight, optimized for phone-class footprint. Everything is open-sourced today under the Apache 2.0 license.

@GoogleCloudTech To manage LLM-wikis, I created a Rust CLI that infers and validates frontmatter fields of markdowns, and then performs hybrid search filtering with SQL clauses. It's a OSS, lightweight, and a skill is available for agent usage github.com/edochi/mdvs

In case you missed it: We recently introduced the Open Knowledge Format (OKF), an open specification that formalizes the LLM-wiki pattern into a portable, interoperable format. How OKF works → goo.gle/3R8Pry7

@nickgomez @openknowledge What's the collaboration engine based on?

@ChioEdoardo @openknowledge Nice, yeah, this is something we’re thinking a lot about (linters, rules engines, etc.). Take a look at our MCP design, may be some useful stuff there re:search

Introducing @OpenKnowledge, the best markdown IDE for humans and agents. Open source. Local and private. LLM-wiki ready. Use with Claude, Codex, and your favorite agent today.

Rewriting Bun in Rust bun.com/blog/bun-in-ru…

@hwchase17 If you want to validate deterministically the frontmatter of the markdowns of your wikis, and leverage it for metadata-filtered hybrid search, have a look at mdvs, a CLI tool I created to manage my personal KB. It's open source a runs locally github.com/edochi/mdvs

anyone looked into or using Open Knowledge Format (github.com/GoogleCloudPla…) for their wikis?

Hot take: I think it's still important to understand the code that our agents write! In this mega thread (based on my AIE talk today), I will explain why that's the case, and show some ideas for how to efficiently understand code. Alright, let's dive in. 1/

Defining a standard format for local, markdown based, wikis is useful, but I think what's missing is a way to force agents to follow this convention. That's why I implemented a CLI, compatible with any agent harness, that makes it easy to validate and search markdown folders. Take a look if interested! github.com/edochi/mdvs

Introducing the Open Knowledge Format (OKF), an open specification that formalizes the LLM-wiki pattern into a portable, interoperable format. AI is only as smart as the context we give it. As we build more advanced, agentic AI systems, they need accurate metadata and context to be useful. But in most organizations, that context is locked inside fragmented data catalogs, isolated wikis, scattered code comments, or the minds of senior engineers. Every time a new AI agent is built, teams are forced to solve the exact same context-assembly problem from scratch. To solve this, we've announced OKF, a vendor-neutral, open specification that formalizes the "LLM-wiki pattern" into a portable, interoperable format. It provides a standardized way to represent the enterprise knowledge that modern AI systems rely on. — Just markdown: readable in any editor, renderable on GitHub, indexable by any search tool — Just files: shippable as a tarball, hostable in any git repo, mountable on any filesystem — Just YAML frontmatter: for the small set of structured fields that need to be queryable: type, title, description, resource, tags, and timestamp We’ve also shipped reference implementations to help you hit the ground running, including an enrichment agent for BigQuery, a static HTML visualizer, and live sample bundles on @github → goo.gle/4uGvAEe ➕ Knowledge Catalog can now natively ingest OKF! Stop reinventing data models and building bespoke integrations for every new AI tool. Here's more about how OKF works → goo.gle/4uGvBbg

I was a Notion fan for a very long time, and for the past couple of years I've been using Obsidian, I love the freedom of local markdown files. Recently I built a CLI that makes it easy to treat a local KB like a DB. Take a look if you're interested! It works well with agent-managed KBs, regardless of the interface you use. github.com/edochi/mdvs

for over a decade i was a hardcore fan of google docs i have not used it for over a year now that ai is here, markdown files in your own computer is the way to go there are two alternatives: - obsidian-like app + an agent (cowork, antigravity) - vs code (integrates both)

@dom_gag_96 done

@ChioEdoardo U need to follow me

For the Italian builders group, we crossed 300 members Closing the door tomorrow (for now - optimisation) Drop a 🍕 and I’ll send you the invite

@tom_doerr Consider pairing it with a tool that validates wikis structures and makes it easy to search in them! github.com/edochi/mdvs

Turns Obsidian notes into persistent AI memory github.com/Ar9av/obsidian…

As you're saying this is a pattern, an interesting (yet opinionated) one, but I really think you need some tool to force your agents to follow the structure you want for your personal KB. I'm developing a CLI in Rust for this use case, a tool that makes it easy to validate and search markdown based wikis Take a look if interested! github.com/edochi/mdvs

Andrej Karpathy quietly shipped the best second brain idea in years not an app. a pattern. let an llm maintain a wiki of your notes. you dump sources, it reads them, links them, files them. knowledge compounds like interest. someone built it into a free claude code plugin. setup is two commands: claude plugin marketplace add AgriciDaniel/claude-obsidian claude plugin install claude-obsidian@agricidaniel-claude-obsidian then open obsidian, open claude code in the same folder, type /wiki. that's it. your notes are now queryable by claude and they get richer every time you read something. bookmark this. best thing you'll build this weekend.

Local KBs managed by agents is the current trend, at least since Karpathy's post. Now Google is suggesting a standard structure for them, but these are conventions, nothing is forcing an agent to follow them. I'm developing a CLI that makes it easy to validate and query markdown based wikis, take a look if interested! github.com/edochi/mdvs

🚨 @Karpathy predicted the power of the "LLM Wiki." Google just formalized it. Meet Open Knowledge Format (OKF): a vendor-neutral standard for giving foundation models the curated context they need. I can genuinely see this replacing Notion, Obsidian, or traditional wikis for developer teams, and the reason comes down to bookkeeping. Traditional wikis fail because humans inevitably abandon the tedious work of updating them. As Andrej Karpathy pointed out recently, LLMs don't get bored. They don't forget to update a cross-reference, and they can touch 15 files in a single pass. OKF standardizes the interoperability layer so agents can actually do that heavy lifting autonomously. Because the format is minimally opinionated, it doesn't dictate what you write, it just dictates how it's structured. You get: → Human-readable documents that live right alongside your code in version control → Cross-links that map out complex entity relationships without needing a graph database → A system that survives moving between different tools and organizations There is no complex compression scheme. No central registry. If you can cat a file, you can read it. If you can git clone a repo, you can deploy it. This is how we stop rebuilding context pipelines from scratch every time a new model drops. Announcement + spec file in 🧵↓

@rohit4verse The issue is that these are conventions, nothing forces the agents to follow them. If anyone is interested in a tool that helps to manage KBs as databases, check out this CLI I'm working on github.com/edochi/mdvs

google just turned karpathy's llm-wiki gist into a spec today: the open knowledge format. markdown files, one required field. the format question is now settled. the hard part still isn't. what it changes: - portability. a bundle is a tarball or a git repo. it moves between orgs and tools with no translation layer. - version control. knowledge lives beside the code it describes, with diffs and history for free. - decoupling. a human writes the bundle, an agent reads it, with no shared tooling between them. - no SDK, no account. you read and write plain markdown. what it leaves to you: - contradiction resolution. a new source fights an old claim. OKF stores both and never says which wins. - staleness. timestamp is a field. retiring a dead fact is a call the format won't make. - merge policy. which page a fact lands on, what gets forked or overwritten. the producer agent owns it. - retrieval. index.md holds for a few hundred pages. past that you need hybrid search and a reranker. OKF standardized the filing cabinet. the librarian is still yours to build.

It's very similar to Karpathy's approach for LLM-organized wikis, it seems that the general trend is to turn personal KBs into semistructured databases managed by agents. However, unlike databases, these are only conventions, and nothing really forces the agents to follow these structures. Personally, I'm trying to solve this with a CLI that makes it easy to validate and search markdown folders. If anyone is interested in taking a look, here's the link github.com/edochi/mdvs

This is really big news. Google introduced the Open Knowledge Format (OKF) - a standardized way to store information in a directory of markdown files. Makes it really easy to make a digital brain that agents can use. These files can serve as a living wiki. You can give agents the ability to query them or edit them. They can interlink. Seems to me this could replace Notion or Obsidian. I can think of so many uses for this. Google's blog post: cloud.google.com/blog/products/… An easier to understand explanation is the SPEC.md file: github.com/GoogleCloudPla… I gave those two links to Antigravity and asked how we could use it for any of the projects we're working on. It came up with so many ideas. I would imagine Claude Fable 5 would whip up some pretty amazing things based on this system. Currently creating an OKF library of our pepper garden. It's going to be a fun weekend.