Big Idea

The argument in one line.

Graphify converts any codebase into a queryable knowledge graph that eliminates Claude Code re-reading tax, and wiring it into a shared agentic OS makes that map available to every agent across every device from a single ingest.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code regularly and notice each new session burning tokens re-reading files it already processed.
You run multiple agents and want them all working from the same codebase understanding.
You maintain a large or complex repo where blast-radius awareness would save iteration cycles.
You want to query any public GitHub repo conversationally without paying to re-ingest it every time.

SKIP IF…

You work on single-file scripts or very small projects where full-context re-reads are trivially cheap.
You are not using Claude Code since Graphify is specific to agentic code workflows.

TL;DR

The full version, fast.

Every Claude Code session without a knowledge graph re-skims your entire repo from scratch, wasting tokens and money. Graphify fixes this by building a persistent graph that reads, clusters, ranks load-bearing files, and labels facts vs. inferences so Claude answers from summaries rather than re-reads. Plug that graph into an agentic OS dashboard alongside Hermes and you get one shared registry that any agent or device can query. Setup is a single prompt to Claude Code pointing at the Graphify repo; indexing runs locally at zero cost.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:46

01 · Graphify Solves the Problem

Hook promising faster, cheaper, more accurate Claude Code via a knowledge graph. Creator intro.

00:46 – 01:21

02 · What Graphify Actually Does

Conceptual explainer using the codebase-as-foreign-country analogy.

01:21 – 02:10

03 · How The Map Works

Four capabilities: reads not summarizes, clusters into modules, ranks guard nodes, labels facts vs. guesses.

02:10 – 03:17

04 · Why Maps Save Tokens

The re-reading tax explained: without map Claude skims whole repo every session; with map answers from summaries and sessions compound.

03:17 – 04:38

05 · Install And Set Up

Live demo: paste Graphify GitHub URL into Claude Code, instruct it to clone and index the Hermes project.

04:38 – 05:04

06 · See The Knowledge Graph

Graphify opens the interactive node-cluster visualization showing module communities.

05:04 – 05:43

07 · Query Any Repo Live

Demo: prompt Claude Code to summarize the repo using the Graphify skill and compare token cost.

05:43 – 06:07

08 · Take It Further

Transition to the Agentic OS layer connecting Hermes, Claude Code, AntiGravity, Codex into one interface.

06:07 – 07:32

09 · Inside The Operating System

Dashboard demo: per-project stats, dollar-savings per conversation, one-click quickfire queries, connect to Hermes.

07:32 – 08:07

10 · Import Any GitHub Repo

Demo: paste any GitHub URL into dashboard, click Graph it, indexes locally at zero cost.

08:07 – 09:04

11 · Chat To Your Projects

Demo: query newly imported repo via Hermes agent; copy the wiring prompt to connect everything.

09:04 – 10:04

12 · Connect Everything Together

One-brain concept: single graph.json shared by Claude Code, Hermes, and the dashboard. Cross-device demo via Telegram.

10:04 – 10:21

13 · Visual Interface Wins

Closing argument: the OS dashboard replaces jumping between chat windows. CTA to watch the agentic OS setup video.

Atomic Insights

Lines worth screenshotting.

Re-reading is the token tax: without a knowledge graph, Claude skims the whole repo every session regardless of how much it processed before.
Graphify runs locally and costs nothing to index; the savings show up as per-conversation dollar estimates inside the dashboard.
A knowledge graph does four things flat code cannot: reads without summarizing, clusters into modules, ranks load-bearing files, and separates extracted facts from inferences.
Every session with Graphify compounds since the graph is always fresh, so each conversation builds on prior understanding rather than restarting.
One ingest, every agent sees it: Claude Code, Hermes, and a mobile client all read the same registry file once Graphify has indexed a project.
You can import any public GitHub repo by URL into the OS dashboard and graph it in seconds.
The dashboard shows per-project file count, link count, cluster count, and estimated dollar savings per conversation before you type a single query.
Blast-radius awareness before editing means the graph tells you every dependency a file change will touch without spending tokens exploring them.
Hermes can call the Graphify skill via Telegram overnight, meaning your agent can review memory and improvements while you sleep.
The gap between having a map and not widens as projects grow since the re-reading tax is roughly proportional to repo size.

Takeaway

The token bill is a re-reading problem, not a compute problem.

WHAT TO LEARN

Every Claude Code session that skims a repo from scratch is paying a re-reading tax that a persistent knowledge graph eliminates entirely.

Without a knowledge graph, an AI agent re-reads the entire codebase at the start of every session: the more files, the more wasted tokens, compounding with every conversation.
A knowledge graph answers queries from summaries rather than raw files, so token spend scales with the question, not the repo size.
Knowing which files are load-bearing before you edit cuts iteration cycles because you can anticipate breakage rather than discover it after the fact.
A shared registry file means every agent and device can access the same codebase understanding without each one independently ingesting the source.
Indexing a project locally at zero cost and recovering per-conversation savings in dollars shifts the economics: setup is a one-time sunk cost, savings are recurring.
The gap between having a map and not having one widens as projects grow since the re-reading tax is roughly proportional to repo size.
Connecting AI tools through a shared data format rather than direct API integrations is more durable: the graph becomes the integration layer.

Glossary

Terms worth knowing.

Knowledge graph: A structured map of a codebase entities and the relationships between them, enabling semantic queries rather than line-by-line reads.
Guard nodes: Graphify term for load-bearing files in a project, the files most other components depend on and that carry the highest change risk.
Re-reading tax: The token cost incurred when an LLM re-ingests an entire codebase at the start of each session because no persistent map exists from the prior session.
Blast radius: The set of files and components affected when a single file is changed. Knowing this before editing prevents cascading breaks in large codebases.
Agentic OS: A personal dashboard that connects multiple AI agents and tools into one shared interface with a common memory and graph registry.
Hermes: The creator custom AI agent that integrates with Claude Code, Telegram, and the agentic OS dashboard; it can query Graphify graphs and run overnight reviews.
graph.json: The shared registry file Graphify writes after indexing a project. Every agent in the agentic OS reads from this single file.

Resources

Things they pointed at.

00:00toolGraphify ↗

00:00toolClaude ↗

05:43toolAntiGravity ↗

05:43toolHermes Agent

03:50productClaude Code Course ↗

Quotables

Lines you could clip.

03:03

“Rereading is the tax that we are saving here.”

Tight quotable framing of the core problem with no setup needed→ TikTok hook↗ Tweet quote

07:27

“It costs us beautifully $0.”

Punchline after the Graph it demo→ IG reel cold open↗ Tweet quote

09:18

“One shared brain with all the stuff.”

Clean architecture summary that is meme-able→ TikTok hook↗ Tweet quote

06:49

“Graphify makes the map and the Agentic OS makes it always on shared and conversational.”

One-sentence dual-product positioning→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphoranalogy

00:00Imagine if Claude code was faster, cheaper, and incredibly accurate.

00:05Graphify just solved Claude code's biggest problem, and it makes all of this possible by creating a knowledge graph of any project for Claude to use. And in this video, I'll show you exactly how to use it and how you can 10 x beyond this by having it within an agentic operating system even if you've never used it before, unlocking capabilities that nobody else is using right now.

00:28And if you're new, I'm Jack. I built and saw my last tech startup with a gazillion customers. Now I'm building my own AI businesses, and I share here the stuff that actually works.

00:36So if you haven't already, grab that beautiful coffee, and let's dive straight in. So Graphify creates this beautiful overview of all of your projects or if you're using it within an agentic operating system, like I'm gonna show you in this video, it takes it to a completely new level.

00:51But we have to actually start by understanding what Graphify physically is. In a nutshell, what Graphify does is gives CoolCode a map. What do I mean by that?

01:00Well, let's say for example that every code base represents a foreign country. Let's say we go to France or Germany.

01:06Without it, we have to learn a language. We kind of have to translate it. But think of Graphify as the ability to speak any language in any country.

01:13You can communicate a lot faster, you can understand exactly what's going on, and it just reduces any latency. But it does a lot more than that, but it really helps you understand conceptually what Graphify is doing.

01:24So think of it like this, we have code. So this could be any application we've got. It could be the agentic operating system, the thing that you're building.

01:31And effectively what happens is, Graphify understands the relationships of all the components within it that makes it easier, faster, better for Claude to talk to her.

01:42Meaning, it spends way less tokens when you actually have a conversation with it. I actually covered it on the channel over a month ago, but I wanna go deeper in it today to show you exactly how it can upgrade your setup. At tilde r, it reads, not summarizes.

01:54It clusters things into modules. It ranks what it calls the guard nodes of the individual projects, which are the load bearing files. And then it labels facts versus guesses, things that it actually extracts and things that it infers from its order.

02:08Now what does a map actually physically help us do? Well, number one is we get instantly orientated with anything.

02:13So say you want to download Claude Bart or you want to download Hermes, you can actually talk to this straight away and understand what's going on. You get grounded answers. You can understand and visualize the impact of all the inter basically, the interconnections.

02:26You can query it instead of using graph, which is basically like a search. It is always fresh and it isn't just code. You get comprehensive understanding beyond what the code is actually about.

02:36So again, incident orientation, grounded answers, blast radius, every dependency before you start editing it. For example, in the community I have, I give away this claw code and Hermes operating system.

02:46Maybe you want to add things to it. Well, using Graphify lets you understand all of the interdependencies within this code.

02:52So you know exactly what affects everything else without spending a gargantillion understanding and paying to do that. That's how freaking cool it is and it's always fresh.

03:01Now the really key thing that you need to understand before we set this up is that rereading actually is the tax that we're saving here. Without the map, it skims a whole repo every single conversation or it just sits in the context. But with the map, we can actually answer it from summaries, which is super beneficial and every session compounds.

03:18To set it up, we head over to this GitHub repo, and I'm just gonna go ahead and copy the code, and then let you straight over to Claude code. Brilliant. And within Claude code, you're gonna say, hey there, dude.

03:27Dude is very important. I want you to go ahead, I want you to clone this repo, and I'd like you to open up my, let's call this, open up Hermes as a test project and basically open up the Graphify window.

03:38Okay. Send this one off. I should say, dude, it is very, important.

03:41And you basically just drop in the URL. Now if you are listening to this and thinking, Jack, this sounds to me like you're speaking Japanese, I have got a full ClawCo course.

03:49I'll put a link down below. I take you from foundation setup through to building beautiful websites, power features, stuff I have never shared on YouTube. I get messages about this daily.

03:59It is the most comprehensive thing I have ever built. It lives. I update it all the time.

04:03You get this, and you also get access to the big beautiful operating system. You just immediately access it. So I'll put a link down below so you can grab that if that would be beneficial for you.

04:11Now what's gonna happen here is, of basically, you're gonna download it. It's already got the repo, which is fine. And what it will do is index that particular file.

04:19So the way this works is you can basically when you download the graphify skill is you can graphify, so to speak, any particular project that you've got, and then it just enables you to query that project in a much more meaningful way.

04:31You understand the relationships and interdependencies of it rather than just looking at flat code, and it just makes the whole experience way better.

04:39And when done, this is the Hermes system. You can see now, I've got all the interactive graphs here.

04:44Now it's basically a big beautiful circle, kinda looks like planet Earth to some extent. Right? Shows all the communities.

04:51Realistically though, this is just a kind of visuality thing. I can unlink communities if I want to. But we can generally see that when we look at this graph, what's helpful to understand is the clustering at where all the things actually link together.

05:02But the real magic happens when you give it a prompt. So I might come back and say, hey there, I'd like to go ahead and summarize what this repo is using the Graphify skill.

05:11Okay. Go ahead. And this is an example now, whenever you're basically talking about any repo, we can use this Graphify skill to drastically cut our costs out.

05:18And then just like that, we've got a basic summation from Claude Code explaining the differences about it and it's understood all of that which is great information. And let's use Graphify to go ahead and do that. You can just compare by the way using Graphify and not Graphify and you will understand the difference as to why this actually saves you so much time.

05:35But not only does it save us time, it saves us cost, it's just a more effective way of talking to and understanding any CAM code base, which is a really important skill. But we can take it one step further. Now here's the AgenTic operating system.

05:47Now the interesting thing about this operating system, as you know, it connects to many other things. It lets us bring in everything from Hermes, everything we're doing with Clawd Code, anti gravity, codex. Everything is in one location.

05:58I can see my spend. I can see my skills. I it dreams for me overnight to find improvements based on our chat history.

06:04It does a lot of incredible, beautiful things that just save us lots of time. I've got a lot of videos on it on the channel. But the really interesting thing for us here that we can do is we can actually now look at different coding graphs that I've kind of ingested here and ask questions about it.

06:17Say for example, you wanna connect this to Hermes, you can do. Now check this out. I've got the CloridCode operating system here.

06:22I can now see on the right hand side. Look. Here's number files, number of links, number of clusters.

06:26I get these deep this detailed information, as well as how much money I'm actually gonna be saving per conversation in dollars and cents. And what's really cool is you can actually then have these Quickfire things here.

06:36Like, let's say for example, I've got Claude OS and I wanna understand what does this project do. I can actually click that, come down here, and I can connect it to Hermes and I can just have a conversation directly in my ClawdCode operating system about anything and it's all fully connected from Hermes agent to Claude Code to this incredible Claude Code operating system and just lets us connect everything together.

06:56And when we put it inside the operating system, as I say, Graphite makes the map and the Ejendic OS makes it always on shared and conversational. Here's why it's so important. We have now one shared brain with all the stuff.

07:07Right? So Hermes, ClaudeCode, and the dashboard, they read one registry registry in GraphOne's. What does that mean?

07:13Let's say that you're doing work at your laptop on ClaudeCode, then your mobile, you can now actually connect this with OpenClore and Hermes, and we're all reading off the same page because it's already been done in one system. It's a map that you can talk to. So whenever you wanna understand anything about any project, you can literally just go to this operating system, select the thing you wanna chat to, and then have a full conversation with it, and it's all completely connected.

07:34You can also import any GitHub repo you want to. So let's say, for example, I grab one from GitHub right now. So this is a power design one that I made.

07:41Let's say I just simply come down, I copy the code, I come straight back over then to our beautiful operating system, I can come down here to add project at the top. I literally just drop it in. I click on graph it.

07:51It costs us beautifully $0. And now this is essentially running Graphify on our computer. And now we have power design, which explains everything that goes on in power design.

07:59Here's a brand style MD. Here's a responsive behavior, here's our layout. And now, if I want to, I can literally just talk to Hermes agent about it or Clued Code.

08:07That's how powerful this is. And now if I want to, I can literally just have a conversation with Power Design straight away. For example, if you're using the Hermes app, I can also come down and say, hey there dude, could you use the graphite skill to tell me about the Clawd Code operating system and how it works?

08:21And now Hermes itself can go ahead and actually use all that information if you give it the ability, as I'll show you right now, I come over here for example, I've got a specific prompt that literally just come down, You show this prompt right here. You copy it, and this is the full instructions of how to connect everything together, and that will work flawlessly.

08:36Or if you're building your own agenda cooperating system, I would recommend that you get some kind of dash panel like this, so you can literally clearly and easily and visually just dip into different repos and very quickly add it to your computer to actually understand and query those files without wasting any time. And so the idea here is that it's wired into everything.

08:54Okay? Basically, you can feed your overnight reviews of memory. Hermes can ask everything from Telegram, is fantastic because it can just automatically reach out to you and ask you questions.

09:02And so ideally, we wanna take this further by having one brand that's kinda shared by everything together, graphite wise into core code, Hermes, and your home operating system so we can connect everything together into one beautiful system. And so one of the biggest benefits of this is you're not gonna spend a, like I say, a Gargan telling tokens actually querying and understanding any new code base.

09:22It is gonna give you more accurate answers as well. So if you wanna take something like this or any file or project that you see and you wanna do certain amends to it, you're gonna have less time wasted on iterating it because Claude can actually understand what the code base is. And likewise, now you can go back and ask Claude the same question.

09:39I like to show you how it integrates with every software just should you know exactly how to connect everything together. I can come down here now, for example, it's gone down and explained the ClaudeCode operating system, explained the relationships, the nodes, how it all connects together, which is fantastic because basically Hermes agent is also connected to ClaudeCode.

09:55But again, you can do this anything you want to. You can just run it directly in Claude Code and only have it here and just speak to Claude Code. Any of these options are possible, but now we have a beautiful visual interface to actually just make it easy and understand rather than jumping from chat window to chat window.

10:10Now, Graphify is incredible, but if you're not using an agentic operating system, you're leaving so much value on the table. So the next thing we need do is learn how to set one of those up by watching this video right here.

The Hook

The bait, then the rug-pull.

Every Claude Code session burns tokens re-reading files it already saw. Graphify builds the map that fixes this, and in a 10-minute demo the creator shows how wiring that map into a shared agentic OS dashboard makes it available to every agent across every device from a single ingest.

Frameworks