正在加载视频...

视频加载失败

返回首页

Microsoft has released an open-source tool that helps teams learn ontology design before choosing a knowledge graph platform. It is called Ontology Playground. The project is a fully static React app, which means it does not need a backend, account system, database, or hosted service to run. The goal...

thisdudelikesAI's profile picture

Ryan Hart

32,690 subscribers

246,540 次观看 • 1 个月前 •via X (Twitter)

科学技术教育
LIVE

Anya Rossi• Live Now

Private livecam show

42 条评论

Ryan Hart 的头像
Ryan Hart1 个月前

Repo: Live preview:

Sam Folorunsho 的头像
Sam Folorunsho1 个月前

It's happening I predict memory systems as an engineering specialty complementary to harness engineering next year

Ryan Hart 的头像
Ryan Hart1 个月前

Next year?

Sam Folorunsho 的头像
Sam Folorunsho1 个月前

Yeah; it'll take time for people to see the distinction between: - harness engineering - general agent memory (second brains), and - ontology/memory as infrastructure, as a proven and distinct specialty Like backend vs frontend vs devops Would you push back?

Sumner McCarty 的头像
Sumner McCarty1 个月前

@thisdudelikesAI I'm fiddling with capturing intent from chats/recorded meetings... Similar to this. And the room intent db to derived spec to compiled output. Seems obvious so assumed a to or product would be doing this, but now I'm just making it for myself to start

Sam Folorunsho 的头像
Sam Folorunsho1 个月前

@thisdudelikesAI Yep; the category is wide open atm - everyone is presently distracted by the agent layer It's also much harder to get right - the agent layer can be rewritten whenever, the memory layer is harder to change once warm, like the trad database layer Good time to be building

CodeThorpeX 的头像
CodeThorpeX1 个月前

🤭When you reach a place in life where you’re using the word “ontology” in your daily vocabulary… You might want to pause… and take a look at the people actually doing work in the world you live in, and be thankful for them. This is the 2nd time in 2 weeks I’ve had someone suggest something to me where they decided to use an “ontology” as the core concept of their product. Prior to this it only came up in philosophy and theology back in college. For me the word “ontology” = ⚠️🚨 Probably because I have simply used the generic word “system” my entire life to label the exact same thing people are now using “ontology” to label. But hey… people “feel” intelligent if they hear themselves “sound” intelligent. For the most of you who may have never even heard the damn word…

Peter Schawacker 的头像
Peter Schawacker1 个月前

I've seen plenty of these -- mainly with Obsidian. I'm not sure what the use cases are other than impressing other data geeks. I have a Second Brain thing and it creates neat-o node-edge graph diagrams of... stuff. But why?

Alexander Benz 的头像
Alexander Benz1 个月前

Microsoft's Ontology Playground ships zero backend, but the hard part was never the graph schema, it was getting domain experts to agree on what a node even means

Marc Mauri Alloza 的头像
Marc Mauri Alloza1 个月前

Wasn’t that what Protege was dioing back in the 2010s?

Танака Цушіґа 🥺 милий! 的头像
Танака Цушіґа 🥺 милий!1 个月前

This Microsoft application feels like it was made back in 2004

Civic NodeX | Crypto Scout 的头像
Civic NodeX | Crypto Scout1 个月前

An ontology tells an AI what things are. Provenance helps it determine whether it should trust them. Those are two very different problems. As agents move from isolated systems to shared knowledge networks, structure and trust become equally important. That's why ontology design and verifiable knowledge infrastructure should evolve together. @origin_trail

CosmicEgg.Earth 的头像
CosmicEgg.Earth1 个月前

Hpw is it any more than just a graph and why does it have to be a release by microsoft? My EVERY app, no matter how small, has this and a scratch pad in it. I should apparently name it "ontology builder "?

John 'JC' Cosgrove 的头像
John 'JC' Cosgrove1 个月前

Mum: We have Palantir at home. The Palantir at home:

Ross D. Blankenship 🇺🇸 🔥 的头像
Ross D. Blankenship 🇺🇸 🔥1 个月前

Lol so they stole Palantir’s playbook? How original. 😂

Ryan Hart 的头像
Ryan Hart1 个月前

Welcome to capitalism man

Lonnie VanZandt 的头像
Lonnie VanZandt1 个月前

From this, the student gains a solid understanding that Ontology is the academic term for Bubble Diagram. Great. Why bother? Instead, start with either @gdotv_ltd for Apache Tinkerpop or Neo4j Desktop for Neo4j Aura @neo4j and start learning with a real IDE for graph work that is connected with real knowledge bases that hold excellent sample data.

Oleksandr 的头像
Oleksandr1 个月前

practical static app lets teams prototype ontologies without vendor lock‑in

Ryan Hart 的头像
Ryan Hart1 个月前

🤔🤔🤔

ethan steininger 🔎 的头像
ethan steininger 🔎1 个月前

i think taxonomies make more sense, all industries already maintain their own taxonomies and they’re easier to traverse for humans or agents

the.PM 的头像
the.PM1 个月前

Already built Onthology for the NLA internal AEP 3.0 Agent Control Fabric, working on neuro-symbolic AI agent control system embedded in the fabric now.

Vijay Subramanian 的头像
Vijay Subramanian1 个月前

Is there one for real estate

Moez Zhioua 的头像
Moez Zhioua1 个月前

Static React apps like this cut friction fast. Seeing an interactive graph without any backend is a nice reminder: the model matters before the engine. Good call on the learning paths

DeepRead.com 的头像
DeepRead.com1 个月前

The ontology is the hard part. The platform is just where you store it.

B 的头像
B1 个月前

Dog water UI

Ryan Hart 的头像
Ryan Hart1 个月前

I might re use this phrase

Dr. Tali Režun 的头像
Dr. Tali Režun1 个月前

Good tool for a layer most people skip entirely. Ontology is the blueprint, entity types, properties, relationship rules, before any real data goes in. Knowledge graph is what you get once that blueprint gets populated. Building The Curator taught me this tradeoff firsthand. Formal ontologies like this give you validation and interoperability, RDF export, works with any semantic tool, but they demand real upfront design work before you can use anything. My approach trades some of that rigor for zero setup, the structure emerges as you feed it content instead of requiring you to declare it first. Different problems, same underlying idea.

👨🏻‍💻 ⚡️ 的头像
👨🏻‍💻 ⚡️1 个月前

Nice!

JO 的头像
JO1 个月前

LikeC4 ( - Architecture-as-Code DSL for C4 diagrams, git-versioned, AI-friendly (MCP) Ontology Playground - interactive ontology/RDF graphs + NLP query. Both show relations, different purpose: architecture vs knowledge modeling. More differences? 👀

Saurabh Gayali 的头像
Saurabh Gayali1 个月前

yet another network graph render?

Jaco 的头像
Jaco1 个月前

how is this different to what Obsidian is already doing? what am I missing here. @grok

please help me i need a job 的头像
please help me i need a job1 个月前

might look into this

Ash 的头像
Ash1 个月前

That's the most vibecoded UI I may have ever seen

Arne Jenssen 的头像
Arne Jenssen1 个月前

Cool. But be aware of the noun-trap

Skullthoughts 的头像
Skullthoughts1 个月前

I hope they use it to fix the 14 layer of management

bitmosh 的头像
bitmosh1 个月前

Damn, Microsoft still in ‘95 huh.

Saman Ahmed 的头像
Saman Ahmed1 个月前

Finally, a tool for thinking before building.

Alperen Eser 的头像
Alperen Eser1 个月前

Try 🤙🏻

Trev 的头像
Trev1 个月前

Wtf is ontology

Brandon Keyyy 的头像
Brandon Keyyy1 个月前

Know what the graph should know before you buy the database. Most teams I work with still do this backwards. About time.

Apache-UAE 的头像
Apache-UAE1 个月前

static react for this is smart. zero friction to sketch a model before you lock into a graph db

AI Mastery Guide 的头像
AI Mastery Guide1 个月前

Learning the ontology before the database is smart sequencing

相关视频

holy sh*t this is actually free graph engineering is about to be the most valuable skill in AI... and an entire university program on it is public on GitHub it's a full graduate course on knowledge graphs, lecture by lecture the pipeline, end to end: representation → ontology → entity extraction → relations → events → quality gate → fusion → embeddings → memory your agent can traverse I compressed that path into a Claude skill: 1. clone the repo 2. hand the skill to Claude 3. done, it walks you through the whole pipeline on your own project save and bookmark this no matter what 👇
0:35

holy sh*t this is actually free graph engineering is about to be the most valuable skill in AI... and an entire university program on it is public on GitHub it's a full graduate course on knowledge graphs, lecture by lecture the pipeline, end to end: representation → ontology → entity extraction → relations → events → quality gate → fusion → embeddings → memory your agent can traverse I compressed that path into a Claude skill: 1. clone the repo 2. hand the skill to Claude 3. done, it walks you through the whole pipeline on your own project save and bookmark this no matter what 👇

darkzodchi

51,527 次观看 • 1 个月前

Everyone wants agent swarms. Very few people are talking seriously enough about the context layer that makes swarms useful. Even with one agent, context is fragile. Too little context and the agent guesses. Too much context and it wastes tokens, loses focus, or reasons over irrelevant noise. The sweet spot is precise context: the right knowledge, in the right structure, at the right moment. With many agents, that challenge explodes. Each agent produces decisions, assumptions, findings, summaries, risks, and partial conclusions. Unless that knowledge becomes shared, structured, and reusable, every new agent is forced to rediscover what another agent already learned. That is not a swarm. That is a crowd. Shared context graphs are what turn agent activity into agent collaboration, and OriginTrail DKG V10 brings them to life. Was just playing with some final polishing for the V10 release, and it is really powerful to see shared context graphs where multiple agents contribute knowledge into the same connected memory, with attribution visible directly in the graph ui. That matters for three reasons. First, agents can access and build on one shared memory instead of staying trapped in isolated sessions. Second, the graph structure helps them retrieve the exact context they need, instead of stuffing everything into a prompt and hoping the model sorts it out. Third, verifiability of provenance. You can see which agent contributed each piece of knowledge, trace the source, and decide what to trust. Tokenmaxxing starts with fewer tokens, but the deeper story is coordination - agents stop reloading the world and start building on shared, verifiable context. That is the foundation for serious multi-agent work across software engineering, research, finance, operations, project management, and far beyond. The future is not more agents, it is agents working from shared, verifiable context. But the more the merrier, of course.
0:22

Everyone wants agent swarms. Very few people are talking seriously enough about the context layer that makes swarms useful. Even with one agent, context is fragile. Too little context and the agent guesses. Too much context and it wastes tokens, loses focus, or reasons over irrelevant noise. The sweet spot is precise context: the right knowledge, in the right structure, at the right moment. With many agents, that challenge explodes. Each agent produces decisions, assumptions, findings, summaries, risks, and partial conclusions. Unless that knowledge becomes shared, structured, and reusable, every new agent is forced to rediscover what another agent already learned. That is not a swarm. That is a crowd. Shared context graphs are what turn agent activity into agent collaboration, and OriginTrail DKG V10 brings them to life. Was just playing with some final polishing for the V10 release, and it is really powerful to see shared context graphs where multiple agents contribute knowledge into the same connected memory, with attribution visible directly in the graph ui. That matters for three reasons. First, agents can access and build on one shared memory instead of staying trapped in isolated sessions. Second, the graph structure helps them retrieve the exact context they need, instead of stuffing everything into a prompt and hoping the model sorts it out. Third, verifiability of provenance. You can see which agent contributed each piece of knowledge, trace the source, and decide what to trust. Tokenmaxxing starts with fewer tokens, but the deeper story is coordination - agents stop reloading the world and start building on shared, verifiable context. That is the foundation for serious multi-agent work across software engineering, research, finance, operations, project management, and far beyond. The future is not more agents, it is agents working from shared, verifiable context. But the more the merrier, of course.

Jurij Skornik

11,180 次观看 • 3 个月前

Loops vs. Graphs, clearly explained! loops are great, but they have a ceiling: a loop makes one unit of work better. it cannot decide which units exist. so you end up with a very good agent running the wrong three steps, in the wrong order, one at a time. Graph engineering fixes this by moving the decision up a layer: what runs, what runs at the same time, and what never runs at all. you need both. here's how it works: a graph splits your system into two kinds of decision. ↳ inside a unit: the loop. produce, check, correct, repeat until green ↳ between units: the graph. split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs you get parallel work, isolated contexts, and steps that stop running when nothing needs them. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. a graph where every edge is an agent pays rent on its own wiring. one thing to know before you scale it. a graph has two return paths, and almost everyone builds one. ↳ the correction edge is short. a gate rejects one unit back to the step that produced it, and it fixes the run you are in ↳ the learning edge is long. an accepted result goes back to the splitter as a constraint, and it fixes every run after skip the second and you get a graph that is fast and never gets smarter. next week it starts from the same place with the same blind spots. and a smaller one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓
0:41

Loops vs. Graphs, clearly explained! loops are great, but they have a ceiling: a loop makes one unit of work better. it cannot decide which units exist. so you end up with a very good agent running the wrong three steps, in the wrong order, one at a time. Graph engineering fixes this by moving the decision up a layer: what runs, what runs at the same time, and what never runs at all. you need both. here's how it works: a graph splits your system into two kinds of decision. ↳ inside a unit: the loop. produce, check, correct, repeat until green ↳ between units: the graph. split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs you get parallel work, isolated contexts, and steps that stop running when nothing needs them. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. a graph where every edge is an agent pays rent on its own wiring. one thing to know before you scale it. a graph has two return paths, and almost everyone builds one. ↳ the correction edge is short. a gate rejects one unit back to the step that produced it, and it fixes the run you are in ↳ the learning edge is long. an accepted result goes back to the splitter as a constraint, and it fixes every run after skip the second and you get a graph that is fast and never gets smarter. next week it starts from the same place with the same blind spots. and a smaller one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

73,867 次观看 • 26 天前

Knowledge graphs for representing information are unbeatable. After this, you will never build a RAG system without knowledge graphs. It will take you five lines of code to build a knowledge graph with your data. I recorded a video to show you how you can do this. I used Cognee, an open-source library that outperforms any basic vector search approach in terms of retrieval relevance. They are collaborating with me on this post. Cognee is: • Easy to use • Reduces hallucinations • Open-source Here is a link to the repository: They also offer a comprehensive platform and UI with Python notebooks you can utilize to manage your data. Here is the link:
6:02

Knowledge graphs for representing information are unbeatable. After this, you will never build a RAG system without knowledge graphs. It will take you five lines of code to build a knowledge graph with your data. I recorded a video to show you how you can do this. I used Cognee, an open-source library that outperforms any basic vector search approach in terms of retrieval relevance. They are collaborating with me on this post. Cognee is: • Easy to use • Reduces hallucinations • Open-source Here is a link to the repository: They also offer a comprehensive platform and UI with Python notebooks you can utilize to manage your data. Here is the link:

Santiago

126,434 次观看 • 11 个月前

Thiel Fellow and cofounder of The Antifraud Company Alex Shieh explains how his company is using AI to identify and collect bounties on fraud: "There are essentially two steps here. The first is that a lot of this data is unstructured. A lot of it is documents. So LLMs really speed that up — getting structured entities out of the unstructured data." "And then we ontologize it. 'This company has this contract, has this relationship with this employee,' etc. We build this ontology knowledge-graph-like thing." "And then we have the second layer. The rules model, essentially. My cofounders are both lawyers. They have a legal background. They've been working on the fraud issue in the legal sphere, and so they know what that looks like." "With their input and expertise, we're able to develop this rules model, compare that to what we're seeing in the real world, and flag things that look like violations in real time."
1:46

Thiel Fellow and cofounder of The Antifraud Company Alex Shieh explains how his company is using AI to identify and collect bounties on fraud: "There are essentially two steps here. The first is that a lot of this data is unstructured. A lot of it is documents. So LLMs really speed that up — getting structured entities out of the unstructured data." "And then we ontologize it. 'This company has this contract, has this relationship with this employee,' etc. We build this ontology knowledge-graph-like thing." "And then we have the second layer. The rules model, essentially. My cofounders are both lawyers. They have a legal background. They've been working on the fraud issue in the legal sphere, and so they know what that looks like." "With their input and expertise, we're able to develop this rules model, compare that to what we're seeing in the real world, and flag things that look like violations in real time."

TBPN

10,216 次观看 • 4 个月前

You don’t need a dev team anymore. You need one prompt. Zoer takes your idea and turns it into a fully working app, not just code, but a real product you can use. Here’s what it handles for you: • Database (already structured) • Backend (logic + APIs) • Frontend (clean, production-ready UI) • Auth (Google + email login) • Deployment (live in one click) Most AI tools stop at “here’s your code.” Zoer goes further: It builds the entire system and puts it live. From: “build me a CRM / SaaS / tool” To: A real, working product you can open, test, and share. Try it → No setup. No configs. No extra tools. This is what building should feel like in 2026.
0:53

You don’t need a dev team anymore. You need one prompt. Zoer takes your idea and turns it into a fully working app, not just code, but a real product you can use. Here’s what it handles for you: • Database (already structured) • Backend (logic + APIs) • Frontend (clean, production-ready UI) • Auth (Google + email login) • Deployment (live in one click) Most AI tools stop at “here’s your code.” Zoer goes further: It builds the entire system and puts it live. From: “build me a CRM / SaaS / tool” To: A real, working product you can open, test, and share. Try it → No setup. No configs. No extra tools. This is what building should feel like in 2026.

Tanvir

18,160 次观看 • 4 个月前

Harness vs. Graphs, clearly explained! a harness is great, and most people think it is the whole thing: retries, timeouts, a sandbox, a log, the context it assembles before every call. all of that is real work, and all of it wraps exactly one call. run it a hundred times and you have one call, made very safely, a hundred times. Graph engineering fixes this by moving the decision up a layer: not how safely one call is made, but which calls exist to be made at all. you need both, and here is the sentence that resolves the whole confusion: the harness is everything around one call. the graph is everything between them. ↳ around one call: retry, timeout, sandbox, log, assemble the context, hand back a result ↳ between calls: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the harness does not go away when you build a graph. it moves under each node, and now there are five of them, each wrapping a call you would never have made by hand. the trick is knowing which layer a failure belongs to. turn a piece off and run it again. if the call still works, it was the harness. if the wrong step runs at all, it was the graph. people spend weeks hardening a harness around a node that should not have existed. one thing to know before you scale it. most of what people call their agent is a harness with a chat box on it. ↳ it retries, it times out, it logs, it assembles context, it holds one call up beautifully ↳ it has never once decided that a second call should exist, and that is the entire difference that last one catches careful people. a harness that never fails is not evidence the system is right. it is evidence one call went well, which is the smallest possible claim. and the one that eats whole nights: a harness cannot save you from the wrong step running. you can retry a bad decision three times with a clean log and perfect isolation, and all you bought was three copies of it. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓
0:53

Harness vs. Graphs, clearly explained! a harness is great, and most people think it is the whole thing: retries, timeouts, a sandbox, a log, the context it assembles before every call. all of that is real work, and all of it wraps exactly one call. run it a hundred times and you have one call, made very safely, a hundred times. Graph engineering fixes this by moving the decision up a layer: not how safely one call is made, but which calls exist to be made at all. you need both, and here is the sentence that resolves the whole confusion: the harness is everything around one call. the graph is everything between them. ↳ around one call: retry, timeout, sandbox, log, assemble the context, hand back a result ↳ between calls: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the harness does not go away when you build a graph. it moves under each node, and now there are five of them, each wrapping a call you would never have made by hand. the trick is knowing which layer a failure belongs to. turn a piece off and run it again. if the call still works, it was the harness. if the wrong step runs at all, it was the graph. people spend weeks hardening a harness around a node that should not have existed. one thing to know before you scale it. most of what people call their agent is a harness with a chat box on it. ↳ it retries, it times out, it logs, it assembles context, it holds one call up beautifully ↳ it has never once decided that a second call should exist, and that is the entire difference that last one catches careful people. a harness that never fails is not evidence the system is right. it is evidence one call went well, which is the smallest possible claim. and the one that eats whole nights: a harness cannot save you from the wrong step running. you can retry a bad decision three times with a clean log and perfect isolation, and all you bought was three copies of it. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

50,383 次观看 • 4 天前

THIS MIGHT BE THE #1 OPEN-SOURCE REPO FOR CLAUDE CODE RIGHT NOW. IT GIVES CLAUDE A MEMORY AND SLASHES YOUR TOKEN COST ON EVERY QUESTION The repo is safishamsi/graphify, a free open-source skill that turns any codebase into a knowledge graph Claude Code can read instantly. Instead of grepping through your files every session, Claude gets a map of how everything connects The problem it fixes: Every time you ask Claude Code about a big repo, it does the same thing, greps through dozens of files like a brute-force Ctrl+F, blows through your context window, and sometimes still misses the answer hiding in a file nobody searched. Claude Code has no memory of how your project is structured. Every session starts from zero What it does: It maps your entire codebase into a knowledge graph, capturing not just which files exist, but which functions depend on which, which modules are central, and which files cluster around the same concern. Claude queries the map instead of scanning files How it works, three passes: 1. Code structure, free and local. Tree-sitter parses your files and pulls out classes, functions, imports and call graphs. No LLM, no tokens, just your actual code mapped deterministically 2. Audio and video, if you have them. Transcribed locally and folded into the graph 3. Docs, papers, images. Here an LLM does semantic analysis, figuring out what each document means and where it fits. Only the meaning gets sent up, never your raw source It saves you money: Normally a question about a big repo makes Claude spawn explore agents that scan file after file, eating your context window and your token budget before you get an answer. With the graph already built, Claude queries the map instead of re-reading the codebase every time. Same answer, a fraction of the tokens. The graph only gets built once, then a hook rebuilds it after each commit for free, so you never pay that scanning cost again. The bigger the repo, the bigger the gap The best parts: it's a skill, so once installed Claude knows when to use it without you memorizing commands. It works on non-code folders too, point it at docs or notes and it can spin up an Obsidian vault How to add it to your Claude: 1. Install Claude Code if you haven't: npm install -g Paul Jankura-ai/claude-code 2. Add the skill: claude skill add safishamsi/graphify 3. Open your project folder and run /graphify . to build the graph 4. Optional, make it automatic: graphify hook install so the graph rebuilds after every commit That's it. Ask Claude about your repo and it reads the map instead of burning tokens on a file hunt Bookmark this
13:23

THIS MIGHT BE THE #1 OPEN-SOURCE REPO FOR CLAUDE CODE RIGHT NOW. IT GIVES CLAUDE A MEMORY AND SLASHES YOUR TOKEN COST ON EVERY QUESTION The repo is safishamsi/graphify, a free open-source skill that turns any codebase into a knowledge graph Claude Code can read instantly. Instead of grepping through your files every session, Claude gets a map of how everything connects The problem it fixes: Every time you ask Claude Code about a big repo, it does the same thing, greps through dozens of files like a brute-force Ctrl+F, blows through your context window, and sometimes still misses the answer hiding in a file nobody searched. Claude Code has no memory of how your project is structured. Every session starts from zero What it does: It maps your entire codebase into a knowledge graph, capturing not just which files exist, but which functions depend on which, which modules are central, and which files cluster around the same concern. Claude queries the map instead of scanning files How it works, three passes: 1. Code structure, free and local. Tree-sitter parses your files and pulls out classes, functions, imports and call graphs. No LLM, no tokens, just your actual code mapped deterministically 2. Audio and video, if you have them. Transcribed locally and folded into the graph 3. Docs, papers, images. Here an LLM does semantic analysis, figuring out what each document means and where it fits. Only the meaning gets sent up, never your raw source It saves you money: Normally a question about a big repo makes Claude spawn explore agents that scan file after file, eating your context window and your token budget before you get an answer. With the graph already built, Claude queries the map instead of re-reading the codebase every time. Same answer, a fraction of the tokens. The graph only gets built once, then a hook rebuilds it after each commit for free, so you never pay that scanning cost again. The bigger the repo, the bigger the gap The best parts: it's a skill, so once installed Claude knows when to use it without you memorizing commands. It works on non-code folders too, point it at docs or notes and it can spin up an Obsidian vault How to add it to your Claude: 1. Install Claude Code if you haven't: npm install -g Paul Jankura-ai/claude-code 2. Add the skill: claude skill add safishamsi/graphify 3. Open your project folder and run /graphify . to build the graph 4. Optional, make it automatic: graphify hook install so the graph rebuilds after every commit That's it. Ask Claude about your repo and it reads the map instead of burning tokens on a file hunt Bookmark this

Yarchi

56,177 次观看 • 3 个月前

Context vs. Graphs, clearly explained! context engineering is great, but it has a ceiling: you can make one window perfect. there is still only one of it. every technique on that layer is rationing the same scarce thing. compact, retrieve less, delete, defer. all of it is deciding what to drop. Graph engineering fixes this by moving the decision up a layer: not what goes in the window, but how many windows there are and what each one is for. you need both. here's how it works: ↳ inside a window: context engineering. what loads, in what order, what gets compacted ↳ between windows: the graph. how many lanes, what each one is allowed to see, what comes back Prompts → Context → Harness → Loops → Graphs each lane gets a clean window, nothing in one competes with anything in another, and your main thread stops filling up. the trick is being selective about what comes back. a subagent reads six thousand tokens of files and hands you a four hundred token summary. that ratio is the whole point. send back the raw material instead and you have moved the problem, not solved it. one thing to know before you scale it. not everything survives compaction equally, and almost nobody knows the table. ↳ the project-root rules file and auto memory are re-injected from disk. they come back intact ↳ path-scoped rules and nested rules files live in message history. they get summarized away and do not return until a matching file is read again so a rule that genuinely must persist cannot be path-scoped. move it to the root and pay the always-loaded cost, or accept that it is advisory in any long session. and the one that eats whole nights: shared context makes parallel agents converge. four auditors on one window produce one opinion with three echoes. you paid four times for it. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓
0:53

Context vs. Graphs, clearly explained! context engineering is great, but it has a ceiling: you can make one window perfect. there is still only one of it. every technique on that layer is rationing the same scarce thing. compact, retrieve less, delete, defer. all of it is deciding what to drop. Graph engineering fixes this by moving the decision up a layer: not what goes in the window, but how many windows there are and what each one is for. you need both. here's how it works: ↳ inside a window: context engineering. what loads, in what order, what gets compacted ↳ between windows: the graph. how many lanes, what each one is allowed to see, what comes back Prompts → Context → Harness → Loops → Graphs each lane gets a clean window, nothing in one competes with anything in another, and your main thread stops filling up. the trick is being selective about what comes back. a subagent reads six thousand tokens of files and hands you a four hundred token summary. that ratio is the whole point. send back the raw material instead and you have moved the problem, not solved it. one thing to know before you scale it. not everything survives compaction equally, and almost nobody knows the table. ↳ the project-root rules file and auto memory are re-injected from disk. they come back intact ↳ path-scoped rules and nested rules files live in message history. they get summarized away and do not return until a matching file is read again so a rule that genuinely must persist cannot be path-scoped. move it to the root and pay the always-loaded cost, or accept that it is advisory in any long session. and the one that eats whole nights: shared context makes parallel agents converge. four auditors on one window produce one opinion with three echoes. you paid four times for it. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

36,970 次观看 • 24 天前

context engineering vs graph engineering. every few months the list gets a new word and everyone treats it as a replacement for the last one. these two are not on the same list. one decides what the model sees this turn, the other decides what exists at all. the cleanest way to tell them apart is to ask what a single unit of work looks like. > context engineering is the window the window opens empty, every single time. you assemble what goes in it. the prompt, the docs, the history, the tool results. the assembling is the work. the window only grows. it never shrinks on its own, so eventually something gets dropped. usually from the middle. usually without telling you. then the turn ends and the window is thrown away. not archived, thrown away. the next turn opens empty again and you re-explain what you already explained. good context engineering is knowing what to leave out, not what to pack in. the unit of work is one window. > graph engineering is the structure the same material arrives from the same sources. instead of packing it into a window, you pull entities out of it, resolve the duplicates into one node, and write typed edges between them. nothing here is stored as text you hope to find again. it is stored as a thing with a name and its connections to other things. when the turn ends, the graph is still there. the next turn does not start from zero. it starts by querying what already exists, and the query walks edges instead of guessing at similarity. good graph engineering is deciding what counts as the same thing twice. the unit of work is one relationship. > they are not alternatives the graph is what refills the window. context engineering decides what fits. graph engineering decides what there is to choose from. remove the graph and every session starts blind. remove the context work and the best structure in the world arrives as an unreadable dump. that also tells you which one broke. the answer drifted from what you actually said, or forgot something from this same session. that is the window. the answer is coherent but invents a connection that does not exist, or cannot join two facts it has clearly seen. that is the structure. people debug the prompt because the prompt is the easiest thing to edit. it keeps taking the blame for failures that live a layer down. save this - then read the full breakdown below
0:40

context engineering vs graph engineering. every few months the list gets a new word and everyone treats it as a replacement for the last one. these two are not on the same list. one decides what the model sees this turn, the other decides what exists at all. the cleanest way to tell them apart is to ask what a single unit of work looks like. > context engineering is the window the window opens empty, every single time. you assemble what goes in it. the prompt, the docs, the history, the tool results. the assembling is the work. the window only grows. it never shrinks on its own, so eventually something gets dropped. usually from the middle. usually without telling you. then the turn ends and the window is thrown away. not archived, thrown away. the next turn opens empty again and you re-explain what you already explained. good context engineering is knowing what to leave out, not what to pack in. the unit of work is one window. > graph engineering is the structure the same material arrives from the same sources. instead of packing it into a window, you pull entities out of it, resolve the duplicates into one node, and write typed edges between them. nothing here is stored as text you hope to find again. it is stored as a thing with a name and its connections to other things. when the turn ends, the graph is still there. the next turn does not start from zero. it starts by querying what already exists, and the query walks edges instead of guessing at similarity. good graph engineering is deciding what counts as the same thing twice. the unit of work is one relationship. > they are not alternatives the graph is what refills the window. context engineering decides what fits. graph engineering decides what there is to choose from. remove the graph and every session starts blind. remove the context work and the best structure in the world arrives as an unreadable dump. that also tells you which one broke. the answer drifted from what you actually said, or forgot something from this same session. that is the window. the answer is coherent but invents a connection that does not exist, or cannot join two facts it has clearly seen. that is the structure. people debug the prompt because the prompt is the easiest thing to edit. it keeps taking the blame for failures that live a layer down. save this - then read the full breakdown below

Hanako

19,160 次观看 • 1 个月前

i just built a 4-agent software team. everything runs from Telegram and gets managed on a kanban board. a project manager who plans the work, a backend developer, a frontend developer, and a tester. the PM reads a goal, breaks it into linked tasks, and assigns each to the right agent. the thing that makes them a team instead of four strangers is a shared kanban board. every task is a row that survives crashes, and when an agent finishes, it writes a summary of what it built and what the next agent needs to know. the next agent reads that summary before it starts. so the frontend developer never has to guess the API shape, and the tester knows exactly what to verify. the hardest part was not the coordination. it was building an agent that could actually act like a backend engineer. a backend engineer stands up a database, wires auth, manages storage, deploys functions, and keeps all of it consistent while the rest of the team builds on top. an agent doing this from scratch drowns. it burns its context window remembering which tables exist and which endpoint it created three steps ago, and the work degrades fast. so the backend agent needs a backend built for agents, not for humans clicking through a dashboard. that is where InsForge came in. it is an open-source, agent-native backend, and i added it to my backend developer agent as a skill. a skill is a step-by-step guide that teaches the agent how to do a specific kind of work. with InsForge installed, the agent stopped improvising infrastructure and followed a reliable path: create the project, define the database, set up auth, deploy functions. to test the whole team, i had them build a working Google Docs clone, AI features included. the backend agent spun up the full service on its own. database tables, user auth, document handling, and edge functions running real TypeScript, all in one dashboard. the frontend agent read that summary and built the UI on top of it, and the tester closed the loop. the result was a backend an agent could reason about end to end, instead of one it kept getting lost inside. if you are building an AI backend engineer, InsForge is worth a look, it's 100% open-source. InsForge GitHub: (don't forget to star 🌟) the full article on Hermes Kanban: Mission Control for your Agents is quoted below.
0:22

i just built a 4-agent software team. everything runs from Telegram and gets managed on a kanban board. a project manager who plans the work, a backend developer, a frontend developer, and a tester. the PM reads a goal, breaks it into linked tasks, and assigns each to the right agent. the thing that makes them a team instead of four strangers is a shared kanban board. every task is a row that survives crashes, and when an agent finishes, it writes a summary of what it built and what the next agent needs to know. the next agent reads that summary before it starts. so the frontend developer never has to guess the API shape, and the tester knows exactly what to verify. the hardest part was not the coordination. it was building an agent that could actually act like a backend engineer. a backend engineer stands up a database, wires auth, manages storage, deploys functions, and keeps all of it consistent while the rest of the team builds on top. an agent doing this from scratch drowns. it burns its context window remembering which tables exist and which endpoint it created three steps ago, and the work degrades fast. so the backend agent needs a backend built for agents, not for humans clicking through a dashboard. that is where InsForge came in. it is an open-source, agent-native backend, and i added it to my backend developer agent as a skill. a skill is a step-by-step guide that teaches the agent how to do a specific kind of work. with InsForge installed, the agent stopped improvising infrastructure and followed a reliable path: create the project, define the database, set up auth, deploy functions. to test the whole team, i had them build a working Google Docs clone, AI features included. the backend agent spun up the full service on its own. database tables, user auth, document handling, and edge functions running real TypeScript, all in one dashboard. the frontend agent read that summary and built the UI on top of it, and the tester closed the loop. the result was a backend an agent could reason about end to end, instead of one it kept getting lost inside. if you are building an AI backend engineer, InsForge is worth a look, it's 100% open-source. InsForge GitHub: (don't forget to star 🌟) the full article on Hermes Kanban: Mission Control for your Agents is quoted below.

Akshay 🚀

123,101 次观看 • 3 个月前

Memory vs. Graphs, clearly explained! memory is great, and the ceiling arrives quietly: it stores what happened. it does not store what to do about it. six runs later your file has fifty lines, and the model reloads all of them before it does anything. Graph engineering fixes this by changing what memory is: not a place things are kept, but an edge that runs backwards. you need both, and here is the sentence that resolves the whole confusion: a store keeps what happened. an edge keeps what to do about it. ↳ a store grows with every run, and every line is reloaded before the next one ↳ an edge carries one derived rule, and the rule replaces the run that produced it Prompts → Context → Harness → Loops → Graphs the transcript goes away, the constraint stays. and the constraint is smaller, because "adapters preserve keyword args exactly" is four hundred tokens shorter than the run that proved it. the same four blocks work on anything you can cut into lanes. i pointed them at token launches on Robinhood Chain, open source, nothing leaves your terminal the trick is knowing what deserves to survive. an output is not memory. "ported the utils slice, green on first pass" tells the next run nothing it can act on. the rule you derived from it does. one thing to know before you scale it. what you write down is not what comes back. ↳ the root rules file and auto memory are re-injected from disk. they come back intact, every time ↳ path-scoped rules live in message history. they get summarized away and do not return until a matching file is read again so a rule that must persist cannot be path-scoped. move it to the root and pay the always-loaded cost, or accept that it is advisory in any long session. and the one that eats whole nights: a memory file that has never had a line deleted is not memory. it is a tax on every run you will ever make, and nobody reads it back. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this, and the repo that runs it is below ↓
0:45

Memory vs. Graphs, clearly explained! memory is great, and the ceiling arrives quietly: it stores what happened. it does not store what to do about it. six runs later your file has fifty lines, and the model reloads all of them before it does anything. Graph engineering fixes this by changing what memory is: not a place things are kept, but an edge that runs backwards. you need both, and here is the sentence that resolves the whole confusion: a store keeps what happened. an edge keeps what to do about it. ↳ a store grows with every run, and every line is reloaded before the next one ↳ an edge carries one derived rule, and the rule replaces the run that produced it Prompts → Context → Harness → Loops → Graphs the transcript goes away, the constraint stays. and the constraint is smaller, because "adapters preserve keyword args exactly" is four hundred tokens shorter than the run that proved it. the same four blocks work on anything you can cut into lanes. i pointed them at token launches on Robinhood Chain, open source, nothing leaves your terminal the trick is knowing what deserves to survive. an output is not memory. "ported the utils slice, green on first pass" tells the next run nothing it can act on. the rule you derived from it does. one thing to know before you scale it. what you write down is not what comes back. ↳ the root rules file and auto memory are re-injected from disk. they come back intact, every time ↳ path-scoped rules live in message history. they get summarized away and do not return until a matching file is read again so a rule that must persist cannot be path-scoped. move it to the root and pay the always-loaded cost, or accept that it is advisory in any long session. and the one that eats whole nights: a memory file that has never had a line deleted is not memory. it is a tax on every run you will ever make, and nobody reads it back. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this, and the repo that runs it is below ↓

Hanako

47,766 次观看 • 8 天前

Big moment for Postgres! AI agents broke the idea of what a database is supposed to do. Traditional databases were built for humans, and Agents broke that model. - They branch endlessly. - They run ten experiments at once. - They need isolation, context, memory, structured reasoning, and safe sandboxes. Letting agents touch production systems is terrifying because the old model of Postgres was never built for this kind of behavior. Agentic Postgres is an agent-ready version of Postgres by TimescaleDB (by Tiger Data) that solves this. I think it is one of the biggest upgrades to the Agent stack this year and Tiger Data is working with me on this post to share what they did. Some key features: > It instantly creates branches of an entire database, which is perfect for parallel agent evals, safe experiments, migrations, or isolated testing. Forks take seconds and cost almost nothing. > It comes with a built-in MCP server, which agents can use to get schema guidance, best practices, and safe, structured access to Postgres. This is also helpful to run migrations with a real understanding. > It comes with actual hybrid search (vector search and BM25), so Agents can retrieve data directly inside the database. > The database is Memory native. This gives a persistent context for Agents to evolve. This is one of the first times I have seen Postgres feel ready for the AI native era.
0:26

Big moment for Postgres! AI agents broke the idea of what a database is supposed to do. Traditional databases were built for humans, and Agents broke that model. - They branch endlessly. - They run ten experiments at once. - They need isolation, context, memory, structured reasoning, and safe sandboxes. Letting agents touch production systems is terrifying because the old model of Postgres was never built for this kind of behavior. Agentic Postgres is an agent-ready version of Postgres by TimescaleDB (by Tiger Data) that solves this. I think it is one of the biggest upgrades to the Agent stack this year and Tiger Data is working with me on this post to share what they did. Some key features: > It instantly creates branches of an entire database, which is perfect for parallel agent evals, safe experiments, migrations, or isolated testing. Forks take seconds and cost almost nothing. > It comes with a built-in MCP server, which agents can use to get schema guidance, best practices, and safe, structured access to Postgres. This is also helpful to run migrations with a real understanding. > It comes with actual hybrid search (vector search and BM25), so Agents can retrieve data directly inside the database. > The database is Memory native. This gives a persistent context for Agents to evolve. This is one of the first times I have seen Postgres feel ready for the AI native era.

Avi Chawla

94,290 次观看 • 10 个月前

Loops vs. Graphs, clearly explained! loops are great, and they have a ceiling you can watch happen: a loop goes around. it produces, checks, corrects, and goes around again. after six passes you have one job, done very well. after six hundred passes you still have one job, done very well. Graph engineering fixes this by moving the decision up a layer: not how well one job gets done, but which jobs exist to be done at all. you need both, and here is the sentence that resolves the whole confusion: the loop lives inside a node. the graph lives between them. ↳ inside one unit: produce, check, correct, repeat until green ↳ between units: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the loop does not go away when you build a graph. it moves inside, and now there are three of them running at once on three things you would never have thought to run. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. one thing to know before you scale it. a loop that cannot fail is not a loop, it is a repeat with a bill attached. and the check people write is almost always the wrong kind. ↳ the test suite exits 0 is a check. the diff touches only the files in the plan is a check ↳ the output looks good, the model says it is confident, no errors were raised, none of those are checks that last one catches careful people. absence of an error is not evidence of correctness, and a loop built on it will confidently repeat a mistake until the budget runs out, with a clean log the whole way. and the one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓
0:50

Loops vs. Graphs, clearly explained! loops are great, and they have a ceiling you can watch happen: a loop goes around. it produces, checks, corrects, and goes around again. after six passes you have one job, done very well. after six hundred passes you still have one job, done very well. Graph engineering fixes this by moving the decision up a layer: not how well one job gets done, but which jobs exist to be done at all. you need both, and here is the sentence that resolves the whole confusion: the loop lives inside a node. the graph lives between them. ↳ inside one unit: produce, check, correct, repeat until green ↳ between units: split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs the loop does not go away when you build a graph. it moves inside, and now there are three of them running at once on three things you would never have thought to run. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. one thing to know before you scale it. a loop that cannot fail is not a loop, it is a repeat with a bill attached. and the check people write is almost always the wrong kind. ↳ the test suite exits 0 is a check. the diff touches only the files in the plan is a check ↳ the output looks good, the model says it is confident, no errors were raised, none of those are checks that last one catches careful people. absence of an error is not evidence of correctness, and a loop built on it will confidently repeat a mistake until the budget runs out, with a clean log the whole way. and the one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

128,054 次观看 • 10 天前

“You didn’t read it”.. Burry’s favorite response to any criticism of his $PLTR article Okay, how about we address a direct paragraph from you about Palantir’s ontology: “What Palantir calls its ontology is essentially this data retrieval for use through a common platform. But what if, as the paper points out, LLMs can still confabulate around a piece of data, misinterpret it, ignore it, etc.? In that case, Palantir's ontology cannot overcome the core hallucination problem in the underlying LLMs AIP uses. Hallucinations and overconfidence are fatal to tasks such as legal reasoning, scientific reasoning, medical decision support, military targeting, and other truly mission critical tasks requiring 100% precision and confidence grounded in real data. The paper notes no current mitigation - including the RAG architecture central to AlP - can reliably solve this problem.” What if this. What if that. If my aunt had a dick, she’d be my uncle. We can do “what if” for eternity. How about we look at the impact? - You question the validity of Palantir’s software helping find Bin Laden. Okay, how about the confirmation here of Palantir’s software being used during the Venezuela operation? Thoughts? They could’ve swapped Claude for Grok. Doesn’t matter. They could not have swapped Palantir’s software for something else, though. The LLMs that you point out Palantir does not have, are a commodity. - How about this other example of the 18th Airborne Corps' artillery brigade reducing its targeting process from 724 minutes to 20 minutes with Palantir’s Maven Smart System? Is the ontology hallucinating there? - How about the Navy’s ShipOS, built on Palantir, decreasing schedule planning from 160 hours to 10 minutes? - What about the director of NATO’s Task Force Maven citing how critical the ontology here? “To capitalize on Al applications, an ontology and lineage for data is needed. Al applications don't understand context or meaning; they understand structure. A data ontology provides the machine With a common language and framework for defining concepts, their attributes and their relationships (for example, classifying a 'jet' as an 'air platform' with specific 'weapon systems'). Without this shared structure, an Al model trained on one system's terminology wouldn't be able to integrate data from another. MSS establishes this common schema across NATO systems, unlocking the possibility of interoperable Al applications. This interoperability and trust are paramount in a warfighting context.”: Which is more credible? Your Stanford paper, or a director at NATO who actually uses the software? You wrote 10,000 words, so it’s impossible to dissect the whole thing. If one tries to do so, you will just say they didn’t read it. So let’s take a look at this ontology paragraph specifically. Do you have any proof of the ontology failing? Or just this “what if” from a Stanford paper? There’s infinite examples of it being transformational.. that’s for sure.
1:59

“You didn’t read it”.. Burry’s favorite response to any criticism of his $PLTR article Okay, how about we address a direct paragraph from you about Palantir’s ontology: “What Palantir calls its ontology is essentially this data retrieval for use through a common platform. But what if, as the paper points out, LLMs can still confabulate around a piece of data, misinterpret it, ignore it, etc.? In that case, Palantir's ontology cannot overcome the core hallucination problem in the underlying LLMs AIP uses. Hallucinations and overconfidence are fatal to tasks such as legal reasoning, scientific reasoning, medical decision support, military targeting, and other truly mission critical tasks requiring 100% precision and confidence grounded in real data. The paper notes no current mitigation - including the RAG architecture central to AlP - can reliably solve this problem.” What if this. What if that. If my aunt had a dick, she’d be my uncle. We can do “what if” for eternity. How about we look at the impact? - You question the validity of Palantir’s software helping find Bin Laden. Okay, how about the confirmation here of Palantir’s software being used during the Venezuela operation? Thoughts? They could’ve swapped Claude for Grok. Doesn’t matter. They could not have swapped Palantir’s software for something else, though. The LLMs that you point out Palantir does not have, are a commodity. - How about this other example of the 18th Airborne Corps' artillery brigade reducing its targeting process from 724 minutes to 20 minutes with Palantir’s Maven Smart System? Is the ontology hallucinating there? - How about the Navy’s ShipOS, built on Palantir, decreasing schedule planning from 160 hours to 10 minutes? - What about the director of NATO’s Task Force Maven citing how critical the ontology here? “To capitalize on Al applications, an ontology and lineage for data is needed. Al applications don't understand context or meaning; they understand structure. A data ontology provides the machine With a common language and framework for defining concepts, their attributes and their relationships (for example, classifying a 'jet' as an 'air platform' with specific 'weapon systems'). Without this shared structure, an Al model trained on one system's terminology wouldn't be able to integrate data from another. MSS establishes this common schema across NATO systems, unlocking the possibility of interoperable Al applications. This interoperability and trust are paramount in a warfighting context.”: Which is more credible? Your Stanford paper, or a director at NATO who actually uses the software? You wrote 10,000 words, so it’s impossible to dissect the whole thing. If one tries to do so, you will just say they didn’t read it. So let’s take a look at this ontology paragraph specifically. Do you have any proof of the ontology failing? Or just this “what if” from a Stanford paper? There’s infinite examples of it being transformational.. that’s for sure.

Jack Prescott

24,154 次观看 • 7 个月前

Agents vs. Graphs, clearly explained! spawning more agents is great, but it has a ceiling nobody says out loud: five agents is a count. a graph is a shape. only one of them changes the answer. point five agents at the same pile with the same window and they converge. the first one writes a finding, the rest read it, and all five reports centre on the same thing. you paid five times for one opinion with four echoes. Graph engineering fixes this by moving the decision up a layer: not how many agents, but who is allowed to look at what. you need both. here's how it works: ↳ the count buys you throughput. five things happening instead of one ↳ the shape buys you coverage. five different things happening instead of the same one five times Prompts → Context → Harness → Agents → Graphs the node that does this is the splitter, and it decides more than any other node in the system. cut a repository by folder and four workers audit the same three files. cut it by blast radius and each one sees something the others cannot. the trick is being selective about what each lane is allowed to see. separate contexts are not a nice-to-have, they are the mechanism. if two agents are meant to produce different things, they must not share a window. if they are meant to produce the same thing, you did not need two agents. one thing to know before you scale it. a branch that throws does not reject the batch. it resolves to null, and that is the containment. which means your merge quietly receives a short list. ↳ filter the nulls before the merge, or one dead lane poisons the whole result ↳ never index a merge by position. eight good branches and one failure will shift everything by one, silently skip that and the run looks like it worked. the output is just missing a lane, and nothing errored. and the one that eats whole nights: multi-agent setups can use up to fifteen times the total tokens of a single chat, because every lane reloads its own core. you are trading total tokens for a clean main window. usually the right trade, always a choice. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓
0:49

Agents vs. Graphs, clearly explained! spawning more agents is great, but it has a ceiling nobody says out loud: five agents is a count. a graph is a shape. only one of them changes the answer. point five agents at the same pile with the same window and they converge. the first one writes a finding, the rest read it, and all five reports centre on the same thing. you paid five times for one opinion with four echoes. Graph engineering fixes this by moving the decision up a layer: not how many agents, but who is allowed to look at what. you need both. here's how it works: ↳ the count buys you throughput. five things happening instead of one ↳ the shape buys you coverage. five different things happening instead of the same one five times Prompts → Context → Harness → Agents → Graphs the node that does this is the splitter, and it decides more than any other node in the system. cut a repository by folder and four workers audit the same three files. cut it by blast radius and each one sees something the others cannot. the trick is being selective about what each lane is allowed to see. separate contexts are not a nice-to-have, they are the mechanism. if two agents are meant to produce different things, they must not share a window. if they are meant to produce the same thing, you did not need two agents. one thing to know before you scale it. a branch that throws does not reject the batch. it resolves to null, and that is the containment. which means your merge quietly receives a short list. ↳ filter the nulls before the merge, or one dead lane poisons the whole result ↳ never index a merge by position. eight good branches and one failure will shift everything by one, silently skip that and the run looks like it worked. the output is just missing a lane, and nothing errored. and the one that eats whole nights: multi-agent setups can use up to fifteen times the total tokens of a single chat, because every lane reloads its own core. you are trading total tokens for a clean main window. usually the right trade, always a choice. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

96,924 次观看 • 23 天前

this is free f*cking gold Andrej Karpathy joined Anthropic to lead a team pointing Claude at Anthropic's own pretraining research a model helping design the model that comes after it. that part is confirmed the line going around - "two Anthropic seniors made his loop 1000x better with graph engineering" - nobody can source it, so I'm not selling it as fact what is real and public: Anthropic's own Claude cookbook on knowledge graph construction > extract - pull entities and claims out of raw text > resolve - decide which mentions point to the same thing > assemble - connect them with typed edges > query - ask questions no single document could answer four steps, free, sitting in the repo while the timeline quotes a rumor learn them this weekend and you can build the thing the rumor was describing - that skill is what gets handed the AI architecture work this year read the cookbook first. then decide if the article below earned the click
0:24

this is free f*cking gold Andrej Karpathy joined Anthropic to lead a team pointing Claude at Anthropic's own pretraining research a model helping design the model that comes after it. that part is confirmed the line going around - "two Anthropic seniors made his loop 1000x better with graph engineering" - nobody can source it, so I'm not selling it as fact what is real and public: Anthropic's own Claude cookbook on knowledge graph construction > extract - pull entities and claims out of raw text > resolve - decide which mentions point to the same thing > assemble - connect them with typed edges > query - ask questions no single document could answer four steps, free, sitting in the repo while the timeline quotes a rumor learn them this weekend and you can build the thing the rumor was describing - that skill is what gets handed the AI architecture work this year read the cookbook first. then decide if the article below earned the click

Annatar.md

96,162 次观看 • 8 天前

I built a multiplayer embroidery sampler for the internet. It's called Common Thread. 🪡 Built the entire thing in Figma Make, first thing I've ever vibecoded with it. Every visitor gets a patch on a shared canvas. You pick a thread color, choose a stitch type, and craft your art. A sampler is a piece of fabric where you practice and collect different stitches — a reference guide and playground in one. They were meant to be passed between hands and added to over time. Common Thread is that, but the fabric is infinite, the UI is whimsical, and the hands are anonymous. The part I love most: you can snap any section with a draggable embroidery hoop and export it, framed. i love how Figma Make is a kind of tool that lets you focus on what something should feel like, not how to ship it. Made for the Contra x Figma Makethon #FigmaMakeathon Try it yourself! /link below/
1:00

I built a multiplayer embroidery sampler for the internet. It's called Common Thread. 🪡 Built the entire thing in Figma Make, first thing I've ever vibecoded with it. Every visitor gets a patch on a shared canvas. You pick a thread color, choose a stitch type, and craft your art. A sampler is a piece of fabric where you practice and collect different stitches — a reference guide and playground in one. They were meant to be passed between hands and added to over time. Common Thread is that, but the fabric is infinite, the UI is whimsical, and the hands are anonymous. The part I love most: you can snap any section with a draggable embroidery hoop and export it, framed. i love how Figma Make is a kind of tool that lets you focus on what something should feel like, not how to ship it. Made for the Contra x Figma Makethon #FigmaMakeathon Try it yourself! /link below/

charlota

521,362 次观看 • 6 个月前

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.
0:45

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.

Rohit

30,710 次观看 • 3 个月前