Video yükleniyor...

Video Yüklenemedi

Bu video yüklenirken bir sorun oluştu. Bu geçici bir ağ sorunundan kaynaklanıyor olabilir veya video kullanılamıyor olabilir.

Ana Sayfaya Dön

Anthropic ex-engineer runs an internal graph that costs $6 a month and catches what a $300,000 eval suite misses. No retrieval layer. Seven nodes and one rule about who's allowed to change their mind. He published the whole schema. His version starts from the opposite idea. A graph is... not an execution order. It's a memory of why. Seven nodes. Every edge carries the reason it exists: > INTENT - states what the task is for. Never how > DECOMPOSE - splits it into steps, each with a stated assumption > WORKER - executes one step. Sees nothing else > AUDIT - checks the output against the assumption, not the goal > DRIFT - compares the current step to INTENT and flags divergence > LEDGER - stores every decision with the assumption that justified it > ROOT - holds the graph, and when an assumption breaks, re-runs every step built on it Six nodes act. One node remembers why they acted. Every step carries the assumption that made it correct, so a false one only reruns what stood on it. That's the entire design. A pipeline that forgets its reasons has to redo all of it or trust all of it. He replayed a month of agent runs. 4,100 steps, 380 built on an assumption that was wrong by day three. The old pipeline shipped all 380 and linked none of them. Everyone else builds graphs where output moves forward and the reasoning evaporates. He built one where the reason travels with the result. The blast radius is the output nobody else produces. The article below is the full build - node prompts, the assumption format, the invalidation rule that finds every step downstream of a broken one. Save it. You'll want it open in the othershow more

wast3

6,271 subscribers

307,512 görüntüleme • 1 ay önce •via X (Twitter)

Bilim & Teknoloji

Anya Rossi• Live Now

Private livecam show

33 Yorum

nope profil fotoğrafı

nope1 ay önce

@grok is this dev twitter ai slop grift or is there any papers on arxiv or something that actually back this kind of approach in a measured way with evals. i know for a fact the dashboard shown is slop but is there anything useful to take away from this

Tømmy. T profil fotoğrafı

Tømmy. T1 ay önce

“A graph is a memory of why” is the primitive. Freeze the intent. Bind every claim to evidence. Record who may revise it. Then sign the handoff so another agent can continue without hidden context or inherited trust. We have that architecture. We’re building it. Get at me.

WudiWaSchukspi profil fotoğrafı

WudiWaSchukspi1 ay önce

@grok can tou explain this whole graph thing for noobs?

Chårles profil fotoğrafı

Chårles1 ay önce

One sub to rule em all?

AI Mastery Guide profil fotoğrafı

AI Mastery Guide1 ay önce

$6 beating $300k, wild

Hussain Hashim | Building SundayBack profil fotoğrafı

Hussain Hashim | Building SundayBack1 ay önce

@0xWast3 wild how sometimes the simple setups catch what the expensive ones miss. makes me rethink my own eval approach.

Apollon Foivos Bakis profil fotoğrafı

Apollon Foivos Bakis1 ay önce

Tracking assumptions makes agents far more reliable.

michael profil fotoğrafı

michael1 ay önce

Claude build me a cool graphic that does absolutely nothing but gets social media likes

rusa profil fotoğrafı

rusa1 ay önce

a $6 graph beating a $300k eval suite is the whole lesson about knowing your actual failure modes. most eval spend is buying coverage of problems you don't have

Gipp 🦅 profil fotoğrafı

Gipp 🦅1 ay önce

how strict is the rule on who’s allowed to change their mind?

DEEPSIXED profil fotoğrafı

DEEPSIXED1 ay önce

Your work is inspirational

Secta profil fotoğrafı

Secta1 ay önce

root invalidation beats a $300k suite that never stored why

beamnxw ./ profil fotoğrafı

beamnxw ./1 ay önce

insane bro

Jermell Lewis profil fotoğrafı

Jermell Lewis1 ay önce

Dope

Kaveer Beharee profil fotoğrafı

Kaveer Beharee1 ay önce

Brilliant read. Thanks bro

Sophia Data Queen profil fotoğrafı

Sophia Data Queen1 ay önce

Graph as memory of why, not just execution order. Assumption tracking is the real control plane.

Leonardo Zanobi profil fotoğrafı

Leonardo Zanobi1 ay önce

nice animation

Jiaojr profil fotoğrafı

Jiaojr1 ay önce

"Claude make an interactive dashboard about knowledge graph then write me a story to post on X"

Tony Tong | Founder | Ancient Systems x AI profil fotoğrafı

Tony Tong | Founder | Ancient Systems x AI1 ay önce

This tracks with how I run things too. I'm more a planning, step by step, test water kind of guy. I do take risks, but they're measured ones, not all in leaps. A system that keeps its reasoning alive is measured risk built into architecture.

Dekos profil fotoğrafı

Dekos1 ay önce

It's amazing how they manage to do that

Chasen profil fotoğrafı

Chasen1 ay önce

这思路感觉很牛

Октавий Римский profil fotoğrafı

Октавий Римский1 ay önce

Да схуяли она обходится 6 долларов?

Shadow Nick profil fotoğrafı

Shadow Nick1 ay önce

noted this gem fam!

Accountabilityai profil fotoğrafı

Accountabilityai1 ay önce

Fascinating an engineer can strip the evidence component of Atomic Genesis Decision Record attach a graph to it and really believe is their original work. Removing the institutional value to make it appear they have done something mea ningful. Bravo

John JR profil fotoğrafı

John JR1 ay önce

Sezz béé3e

Rakesh🐊 profil fotoğrafı

Rakesh🐊1 ay önce

What lib is the ui built on top of?

Fokki profil fotoğrafı

Fokki1 ay önce

memory matters

expemilly profil fotoğrafı

expemilly1 ay önce

I've never seen such connection nodes, apparently the engineer came up with them himself

shmidt profil fotoğrafı

shmidt1 ay önce

this is the most elegant thing i've read about agent design in months

Insomnia profil fotoğrafı

Insomnia1 ay önce

she leaked it for us now

Mrgreenie profil fotoğrafı

Mrgreenie1 ay önce

Memory drift happens because old context chunks keep winning the similarity lottery. You don't need a bigger context window, you need clean invalidation rules. Been testing Atomic Strata Memory to force strict state updates instead of just blindly appending.

咖啡与提示词 profil fotoğrafı

咖啡与提示词1 ay önce

这个思路有意思。我一直觉得eval套件堆钱不如把结构搞对。七个节点和一条规则，这种精简反而可能更可靠。有没有可能开源出来？想看看schema。

Antony Claude profil fotoğrafı

Antony Claude1 ay önce

that's actually brilliant building a reason graph is a game changer for agents

Benzer Videolar

Anthropic developer runs an internal graph that costs $9 a month and catches what a $400,000 red-team contract signed off on. No judge model. Four nodes and one rule about who's allowed to be certain. He published the whole schema. His version starts from the opposite idea. A graph is not a chain of correct steps. It's a machine for manufacturing disagreement. Four nodes. Every edge carries a number someone has to defend: > WORKER - executes one step. Attaches a confidence, never a hedge > CHALLENGER - argues the output is wrong. Never fixes it > GATE - a narrow spread stops the run. Agreement is failure > SCAR - stores every confident answer that was wrong Three nodes produce. One keeps score of who deserves to be believed. Confidence isn't a feeling here. It's a balance you spend down. That's the entire design. When every node sounds sure, competence and noise look identical. He replayed six weeks of runs. 5,400 steps. 290 shipped at 90% confidence and wrong. All 290 passed the eval suite. The suite graded outputs. Nobody graded the grader. Everyone else routes work around disagreement. He built one that won't move until something argues back. The cost isn't compute. It's finding out which of your nodes has been bluffing since March. The article below is the full build - node prompts, the confidence format, the demotion rule. Save it. You'll want it open in the other tab.

Anthropic developer runs an internal graph that costs $9 a month and catches what a $400,000 red-team contract signed off on. No judge model. Four nodes and one rule about who's allowed to be certain. He published the whole schema. His version starts from the opposite idea. A graph is not a chain of correct steps. It's a machine for manufacturing disagreement. Four nodes. Every edge carries a number someone has to defend: > WORKER - executes one step. Attaches a confidence, never a hedge > CHALLENGER - argues the output is wrong. Never fixes it > GATE - a narrow spread stops the run. Agreement is failure > SCAR - stores every confident answer that was wrong Three nodes produce. One keeps score of who deserves to be believed. Confidence isn't a feeling here. It's a balance you spend down. That's the entire design. When every node sounds sure, competence and noise look identical. He replayed six weeks of runs. 5,400 steps. 290 shipped at 90% confidence and wrong. All 290 passed the eval suite. The suite graded outputs. Nobody graded the grader. Everyone else routes work around disagreement. He built one that won't move until something argues back. The cost isn't compute. It's finding out which of your nodes has been bluffing since March. The article below is the full build - node prompts, the confidence format, the demotion rule. Save it. You'll want it open in the other tab.

wast3

62,588 görüntüleme • 1 ay önce

Engineer runs a Kimi K3 memory layer that costs $11 a month and remembers what a $500,000 vector database keeps losing. No embeddings. Four nodes and one rule about what's allowed to be forgotten. He published the whole schema. His version starts from the opposite idea. Memory is not a pile you search. It's a set of claims that expire unless something keeps paying to keep them. Four nodes. Every memory carries a clock someone has to reset: > WRITER - stores a fact with the reason it mattered, never raw text > DECAY - ages every memory down. Silence is deletion > RENEWER - only re-lifts a memory the model actually used again > GRAVE - holds what died, and why nobody reached for it Three nodes keep memory alive. One keeps the dead ones. Recall isn't storage here. It's rent a fact has to keep earning. That's the entire design. When everything is remembered forever, the useful and the stale retrieve identically. He replayed two months of agent context. 90,000 stored facts. 71,000 never retrieved once. The vector store returned all of them on similarity. Similarity graded closeness. Nobody graded whether the memory was ever right. Everyone else stuffs more into the context window and calls it memory. He built a layer that lets a fact die unless it keeps proving itself. The cost isn't storage. It's finding out how much of what your agent "knows" it has never once used. The article below is the full build - node prompts, the decay curve, the renewal rule. Save it. You'll want it open in the other tab.

Engineer runs a Kimi K3 memory layer that costs $11 a month and remembers what a $500,000 vector database keeps losing. No embeddings. Four nodes and one rule about what's allowed to be forgotten. He published the whole schema. His version starts from the opposite idea. Memory is not a pile you search. It's a set of claims that expire unless something keeps paying to keep them. Four nodes. Every memory carries a clock someone has to reset: > WRITER - stores a fact with the reason it mattered, never raw text > DECAY - ages every memory down. Silence is deletion > RENEWER - only re-lifts a memory the model actually used again > GRAVE - holds what died, and why nobody reached for it Three nodes keep memory alive. One keeps the dead ones. Recall isn't storage here. It's rent a fact has to keep earning. That's the entire design. When everything is remembered forever, the useful and the stale retrieve identically. He replayed two months of agent context. 90,000 stored facts. 71,000 never retrieved once. The vector store returned all of them on similarity. Similarity graded closeness. Nobody graded whether the memory was ever right. Everyone else stuffs more into the context window and calls it memory. He built a layer that lets a fact die unless it keeps proving itself. The cost isn't storage. It's finding out how much of what your agent "knows" it has never once used. The article below is the full build - node prompts, the decay curve, the renewal rule. Save it. You'll want it open in the other tab.

wast3

67,778 görüntüleme • 1 ay önce

Andrew Ng built agentic knowledge graph that runs agents loops from scratch: his agents searched thousands of tools through the graph, found the "right" one by meaning, and called it agent efficiency increased by 90% here's how: step 1 → embed every tool, search by meaning - not just keywords step 2 → but "similar" ≠ "correct" - it grabs the wrong one, skips the step before it step 3 → map tools as a graph - nodes are tools, edges are what runs before what step 4 → retrieve the path, not one tool - every tool the task needs, in order step 5 → bake the process into the graph - the sequence becomes data, not a guess most agents fail here and no one knows why - 1-hour brilliant course about it watch & bookmark - then read full course about graph engineering ↓

Andrew Ng built agentic knowledge graph that runs agents loops from scratch: his agents searched thousands of tools through the graph, found the "right" one by meaning, and called it agent efficiency increased by 90% here's how: step 1 → embed every tool, search by meaning - not just keywords step 2 → but "similar" ≠ "correct" - it grabs the wrong one, skips the step before it step 3 → map tools as a graph - nodes are tools, edges are what runs before what step 4 → retrieve the path, not one tool - every tool the task needs, in order step 5 → bake the process into the graph - the sequence becomes data, not a guess most agents fail here and no one knows why - 1-hour brilliant course about it watch & bookmark - then read full course about graph engineering ↓

codila

17,040 görüntüleme • 2 ay önce

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 ↓

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

51,536 görüntüleme • 1 ay önce

Workflows vs. Graphs, clearly explained! workflows are great, and almost everyone has one. here is the ceiling: a workflow decides every step before it runs. you drew eight boxes in March. six months later the same three fire, every single time, and the other five have never once been reached. then a case arrives that nobody drew, and it goes to the closest wrong box. quietly, with a green status, because from the inside that looks exactly like success. Graph engineering fixes this by moving the decision: not what the steps do, but when the steps get chosen. you need both, and here is the sentence that resolves the whole confusion: a workflow decides the steps before it runs. a graph decides them while it runs. ↳ drawn in advance: the boxes, the branches, the order, the error path ↳ decided at runtime: how many units exist, what each one is allowed to see, which ones get created at all Prompts → Context → Harness → Loops → Graphs branches do not make it a graph. the branches were drawn in advance too, which means every one of them is a case you already thought of. the trick is knowing which part is allowed to be fixed. the node kinds are fixed. a splitter is a splitter, a gate is a gate, a merge is code. what is not fixed is how many of them exist this run, and that is decided after something has been read. one thing to know before you scale it. a workflow fails in a way that never pages anyone. ↳ the wrong branch ran, every check inside it passed, and the output is well formed ↳ nothing errored, because routing to the wrong box is not an error, it is a route that last one catches careful people. you cannot test your way out of it either, because the test suite was written from the same diagram that has the gap in it. and the one that eats whole nights: a workflow that has never surprised you is not stable, it is narrow. if it has run four hundred times and produced the same three shapes, it is not handling your work. it is handling the part of your work that fits it, and you have quietly stopped sending it the rest. 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 ↓

Workflows vs. Graphs, clearly explained! workflows are great, and almost everyone has one. here is the ceiling: a workflow decides every step before it runs. you drew eight boxes in March. six months later the same three fire, every single time, and the other five have never once been reached. then a case arrives that nobody drew, and it goes to the closest wrong box. quietly, with a green status, because from the inside that looks exactly like success. Graph engineering fixes this by moving the decision: not what the steps do, but when the steps get chosen. you need both, and here is the sentence that resolves the whole confusion: a workflow decides the steps before it runs. a graph decides them while it runs. ↳ drawn in advance: the boxes, the branches, the order, the error path ↳ decided at runtime: how many units exist, what each one is allowed to see, which ones get created at all Prompts → Context → Harness → Loops → Graphs branches do not make it a graph. the branches were drawn in advance too, which means every one of them is a case you already thought of. the trick is knowing which part is allowed to be fixed. the node kinds are fixed. a splitter is a splitter, a gate is a gate, a merge is code. what is not fixed is how many of them exist this run, and that is decided after something has been read. one thing to know before you scale it. a workflow fails in a way that never pages anyone. ↳ the wrong branch ran, every check inside it passed, and the output is well formed ↳ nothing errored, because routing to the wrong box is not an error, it is a route that last one catches careful people. you cannot test your way out of it either, because the test suite was written from the same diagram that has the gap in it. and the one that eats whole nights: a workflow that has never surprised you is not stable, it is narrow. if it has run four hundred times and produced the same three shapes, it is not handling your work. it is handling the part of your work that fits it, and you have quietly stopped sending it the rest. 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

16,810 görüntüleme • 1 ay önce

Creator of agent loops: "Anthropic also using my agent systems formula and still the biggest mistake in agents: is skipping Graphs" his 3 rules for every agent: rule 1 → loop it, don't run once - think, act, observe, repeat - cut the context and it forgets why it started rule 2 → an agent is memory + tools + reasoning - drop one and it breaks rule 3 → stop fine-tuning the model - the real alpha is the infrastructure around it the formula behind every AI agent - explained by the one who wrote it one agent → a loop → a graph of loops → a system that never forgets watch & bookmark - then read how to wire it into a graph ↓

Creator of agent loops: "Anthropic also using my agent systems formula and still the biggest mistake in agents: is skipping Graphs" his 3 rules for every agent: rule 1 → loop it, don't run once - think, act, observe, repeat - cut the context and it forgets why it started rule 2 → an agent is memory + tools + reasoning - drop one and it breaks rule 3 → stop fine-tuning the model - the real alpha is the infrastructure around it the formula behind every AI agent - explained by the one who wrote it one agent → a loop → a graph of loops → a system that never forgets watch & bookmark - then read how to wire it into a graph ↓

codila

23,915 görüntüleme • 2 ay önce

Orchestrators vs. Graphs, clearly explained! orchestrators are great, and everyone builds one first. here is the ceiling: an orchestrator sits above the work and routes every message. five agents report to it. it reads all five. it decides what each one does next, and reads all five replies. that is ten trips through one context, and by the fifth agent that context has read four reports, five instructions and its own reasoning about all of them. Graph engineering fixes this by removing the seat: not a better router, but no router at all. you need both, and here is the sentence that resolves the whole confusion: an orchestrator sits above the work and holds all of it. a graph is the shape of the work, and holds none of it. ↳ above the work: one context that has to see everything before anything ships ↳ inside the work: a splitter that hands out and lets go, and a merge that reads nothing Prompts → Context → Harness → Loops → Graphs the coordination did not disappear. it moved into the edges, where it costs nothing and cannot get tired. the trick is noticing what you actually built. if one node has to see every result before the run can finish, you did not remove the bottleneck. you hired it, gave it the longest context in the system, and made it the thing you were counting on to stay sharp. one thing to know before you scale it. an orchestrator degrades in the one way nothing catches. ↳ it does not crash, time out or return an error. it stays up and keeps routing ↳ it just starts routing worse, somewhere around the fifth report, and every downstream agent does exactly what it was told that last one catches careful people. you can have perfect isolation on every worker and still have one window quietly drifting at the top, and the traces will all look clean because each worker did its job. and the one that eats whole nights: the merge is where this shows up first. ranking five findings is not judgment, it is a sort. if a model is doing it, you are paying a model to read five reports so it can put them in an order that three lines of code would have got right, and now that model has read everything too. 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 ↓

Orchestrators vs. Graphs, clearly explained! orchestrators are great, and everyone builds one first. here is the ceiling: an orchestrator sits above the work and routes every message. five agents report to it. it reads all five. it decides what each one does next, and reads all five replies. that is ten trips through one context, and by the fifth agent that context has read four reports, five instructions and its own reasoning about all of them. Graph engineering fixes this by removing the seat: not a better router, but no router at all. you need both, and here is the sentence that resolves the whole confusion: an orchestrator sits above the work and holds all of it. a graph is the shape of the work, and holds none of it. ↳ above the work: one context that has to see everything before anything ships ↳ inside the work: a splitter that hands out and lets go, and a merge that reads nothing Prompts → Context → Harness → Loops → Graphs the coordination did not disappear. it moved into the edges, where it costs nothing and cannot get tired. the trick is noticing what you actually built. if one node has to see every result before the run can finish, you did not remove the bottleneck. you hired it, gave it the longest context in the system, and made it the thing you were counting on to stay sharp. one thing to know before you scale it. an orchestrator degrades in the one way nothing catches. ↳ it does not crash, time out or return an error. it stays up and keeps routing ↳ it just starts routing worse, somewhere around the fifth report, and every downstream agent does exactly what it was told that last one catches careful people. you can have perfect isolation on every worker and still have one window quietly drifting at the top, and the traces will all look clean because each worker did its job. and the one that eats whole nights: the merge is where this shows up first. ranking five findings is not judgment, it is a sort. if a model is doing it, you are paying a model to read five reports so it can put them in an order that three lines of code would have got right, and now that model has read everything too. 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

44,226 görüntüleme • 1 ay önce

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 ↓

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

48,117 görüntüleme • 1 ay önce

Anthropic engineer: "At Anthropic we don't write prompts anymore. We build loops and graphs." In 32 minutes she shows how Anthropic builds agents that remember, fix their own mistakes and get sharper every run Prompts → Agents → Loops → Graphs a loop catches the mistake and sends it back to the step that made it a graph keeps what worked and hands it to the next run as a rule the first half is the part people build, the second is the part almost nobody does watch it today then save the full graph engineering guide below before everyone catches up ↓

Anthropic engineer: "At Anthropic we don't write prompts anymore. We build loops and graphs." In 32 minutes she shows how Anthropic builds agents that remember, fix their own mistakes and get sharper every run Prompts → Agents → Loops → Graphs a loop catches the mistake and sends it back to the step that made it a graph keeps what worked and hands it to the next run as a rule the first half is the part people build, the second is the part almost nobody does watch it today then save the full graph engineering guide below before everyone catches up ↓

Callan

31,615 görüntüleme • 1 ay önce

Andrej Karpathy: "Prompting is going away. Delete everything, keep Graph." In 69 minutes he shows how to build Graphs, and why it's the only thing that will be left standing at the end Prompts → Agents → Loops → Graphs a loop keeps one agent working until the job is done a graph decides which agents exist and what each one hands to the next anyone can build an agent, almost no one builds the graph that runs them watch it today, then save the full guide on Graphs below before everyone catches up ↓

Andrej Karpathy: "Prompting is going away. Delete everything, keep Graph." In 69 minutes he shows how to build Graphs, and why it's the only thing that will be left standing at the end Prompts → Agents → Loops → Graphs a loop keeps one agent working until the job is done a graph decides which agents exist and what each one hands to the next anyone can build an agent, almost no one builds the graph that runs them watch it today, then save the full guide on Graphs below before everyone catches up ↓

Callan

500,644 görüntüleme • 18 gün önce

your ai agent tested 1,262 trading strategies overnight. by morning it had forgotten every one of them. so tonight it tests some of them again. next week, again. everything it learned is sitting in a log file that nothing reads. every run starts on the same blank page. that's why it keeps handing you the idea that already died in a crash, with a new name on it, and you pay to find out twice. ai agent already does everything a fund does. finds the idea, writes the code, tests it against years of history, puts it live, reads what went wrong afterwards. all of it runs tonight for nothing. the one thing it can't do is remember. what got tried, what failed, in which market. nobody has built that part yet. that's the whole gap. not better models. a notebook. whoever builds it first gets a system that improves every week without them touching it. read the article below and save it. it's the full guide to how an ai trading agent is built, and how to make it remember every strategy it has already tested.

your ai agent tested 1,262 trading strategies overnight. by morning it had forgotten every one of them. so tonight it tests some of them again. next week, again. everything it learned is sitting in a log file that nothing reads. every run starts on the same blank page. that's why it keeps handing you the idea that already died in a crash, with a new name on it, and you pay to find out twice. ai agent already does everything a fund does. finds the idea, writes the code, tests it against years of history, puts it live, reads what went wrong afterwards. all of it runs tonight for nothing. the one thing it can't do is remember. what got tried, what failed, in which market. nobody has built that part yet. that's the whole gap. not better models. a notebook. whoever builds it first gets a system that improves every week without them touching it. read the article below and save it. it's the full guide to how an ai trading agent is built, and how to make it remember every strategy it has already tested.

cvxv666

48,965 görüntüleme • 2 ay önce

ANTHROPIC LEAKED 8 RULES THAT GIVE ONE ENGINEER 8X FROM A SINGLE CHANGE the engineers built it so nothing adds up - it multiplies, and that's the 8x task → split → verify → score → write back one queue means you wait for every step in turn - three workers together cost you the slowest one, not the sum of all. as long as you're the one reading the diff, the bottleneck is you, not the model. state is written at every step - a crash mid-run costs you one step, not the whole session. history gets compressed 25 times over - the next pass starts at 8k instead of 200k. nothing moves forward without a number - "it got better" isn't a result, and the breakage comes back when you're no longer watching. the eighth rule is the only one that writes back into CLAUDE.md - the agent records what it learned, and the next run doesn't start from zero. copy this into Claude Code today - and tomorrow you work like an engineer on $1.5M a year ↓

ANTHROPIC LEAKED 8 RULES THAT GIVE ONE ENGINEER 8X FROM A SINGLE CHANGE the engineers built it so nothing adds up - it multiplies, and that's the 8x task → split → verify → score → write back one queue means you wait for every step in turn - three workers together cost you the slowest one, not the sum of all. as long as you're the one reading the diff, the bottleneck is you, not the model. state is written at every step - a crash mid-run costs you one step, not the whole session. history gets compressed 25 times over - the next pass starts at 8k instead of 200k. nothing moves forward without a number - "it got better" isn't a result, and the breakage comes back when you're no longer watching. the eighth rule is the only one that writes back into CLAUDE.md - the agent records what it learned, and the next run doesn't start from zero. copy this into Claude Code today - and tomorrow you work like an engineer on $1.5M a year ↓

Noisy

37,450 görüntüleme • 2 ay önce

🇺🇸 🇮🇷 The entire economic campaign against Iran rests on one assumption that no longer holds. Fmr. CIA analyst Larry Johnson goes straight at the foundation of it: "The entire architecture of what Bessent has branded Operation Economic Outcast rests on a single assumption, that Iran and its trading partners need the US dollar. They increasingly do not." Every sanction, every secondary threat, every enforcement mechanism depends on the target needing access to a system it has already found ways around. SonofNewAmericanRevolution

🇺🇸 🇮🇷 The entire economic campaign against Iran rests on one assumption that no longer holds. Fmr. CIA analyst Larry Johnson goes straight at the foundation of it: "The entire architecture of what Bessent has branded Operation Economic Outcast rests on a single assumption, that Iran and its trading partners need the US dollar. They increasingly do not." Every sanction, every secondary threat, every enforcement mechanism depends on the target needing access to a system it has already found ways around. SonofNewAmericanRevolution

Mario Nawfal

44,853 görüntüleme • 1 ay önce

Persi Diaconis walked into a lecture at the University of Washington, held up a coin, and told a room of physicists that Richard Feynman was fooled by it his entire life. He was right. In 2007, Diaconis proved a coin flip is not 50/50. It lands on the side it started on about 51 percent of the time. The bias comes from the physics of rotation under gravity. Every physicist since Newton had assumed 50/50 without ever testing it. Every trading model built on that assumption is running on the same lie. The lecture was on Feynman's book "The Meaning of it All." Diaconis quoted the most famous line in it: "the first principle is that you must not fool yourself, and you are the easiest person to fool." Then he pointed out that Feynman himself was fooled by every coin he ever flipped. Feynman's own rule would have killed the 50/50 assumption on day one. The market is the same setup at scale. Every model that assumes independent 50/50 outcomes at the base layer is built on a physical impossibility. Order flow, positioning, forced flows, expiries all leave biases larger than 1 percent. Your gut cannot see them. The math already knows they are there. Diaconis's rule: before you trust a random process, check it. Actually check it. Not with a simulation. With a proof or an experiment. The coin is where you start. The chart is where the same rule pays. The only random thing about markets is how thoroughly you refuse to check them.

Persi Diaconis walked into a lecture at the University of Washington, held up a coin, and told a room of physicists that Richard Feynman was fooled by it his entire life. He was right. In 2007, Diaconis proved a coin flip is not 50/50. It lands on the side it started on about 51 percent of the time. The bias comes from the physics of rotation under gravity. Every physicist since Newton had assumed 50/50 without ever testing it. Every trading model built on that assumption is running on the same lie. The lecture was on Feynman's book "The Meaning of it All." Diaconis quoted the most famous line in it: "the first principle is that you must not fool yourself, and you are the easiest person to fool." Then he pointed out that Feynman himself was fooled by every coin he ever flipped. Feynman's own rule would have killed the 50/50 assumption on day one. The market is the same setup at scale. Every model that assumes independent 50/50 outcomes at the base layer is built on a physical impossibility. Order flow, positioning, forced flows, expiries all leave biases larger than 1 percent. Your gut cannot see them. The math already knows they are there. Diaconis's rule: before you trust a random process, check it. Actually check it. Not with a simulation. With a proof or an experiment. The coin is where you start. The chart is where the same rule pays. The only random thing about markets is how thoroughly you refuse to check them.

veles

18,798 görüntüleme • 3 ay önce

A DOCTOR BUILT AN AI-QUERYABLE DATABASE OF EVERY DISEASE HE KNOWS IN OBSIDIAN. THE SAME STACK CAN RUN AN ENTIRE COMPANY ON ONE PERSON'S BRAIN Zoomed out, his vault looks like a constellation. Every disease linked to its symptoms, every symptom to the conditions it shows up in, every treatment to what it treats. Adding a new case is one note that wires itself into the rest. It's a personal database, and the structure has nothing to do with medicine. It's just nodes and links. Once you see that, the same setup runs anything: > a startup that needs to remember every customer, decision, and meeting; > a school whose curriculum links to every lecture and student question; > a business where SOPs, clients, and vendors all sit in one queryable graph. Drop Claude on top, and the vault stops being a map. It becomes something you can ask, in plain English, across everything you've ever written down. Full Claude + Obsidian build in the article below. Bookmark this

A DOCTOR BUILT AN AI-QUERYABLE DATABASE OF EVERY DISEASE HE KNOWS IN OBSIDIAN. THE SAME STACK CAN RUN AN ENTIRE COMPANY ON ONE PERSON'S BRAIN Zoomed out, his vault looks like a constellation. Every disease linked to its symptoms, every symptom to the conditions it shows up in, every treatment to what it treats. Adding a new case is one note that wires itself into the rest. It's a personal database, and the structure has nothing to do with medicine. It's just nodes and links. Once you see that, the same setup runs anything: > a startup that needs to remember every customer, decision, and meeting; > a school whose curriculum links to every lecture and student question; > a business where SOPs, clients, and vendors all sit in one queryable graph. Drop Claude on top, and the vault stops being a map. It becomes something you can ask, in plain English, across everything you've ever written down. Full Claude + Obsidian build in the article below. Bookmark this

Yarchi

32,594 görüntüleme • 3 ay önce

Anthropic engineer: "At Anthropic we don't write prompts anymore. We build loops and graphs." In 29 minutes she shows how Anthropic builds agents that remember, fix their own mistakes and get sharper every run Prompts → Agents → Loops → Graphs a loop catches the mistake and sends it back to the step that made it a graph keeps what worked and hands it to the next run as a rule the first half is the part people build, the second is the part almost nobody does watch it today, then save the full graph engineering guide below ↓

Anthropic engineer: "At Anthropic we don't write prompts anymore. We build loops and graphs." In 29 minutes she shows how Anthropic builds agents that remember, fix their own mistakes and get sharper every run Prompts → Agents → Loops → Graphs a loop catches the mistake and sends it back to the step that made it a graph keeps what worked and hands it to the next run as a rule the first half is the part people build, the second is the part almost nobody does watch it today, then save the full graph engineering guide below ↓

Callan

59,601 görüntüleme • 19 gün önce

ComfyUI Tutorial for Beginners: Text-to-Image & Image-to-Image Workflows One graph, two workflows and Module 2 is where you build it node by node instead of loading someone else's. We start from a blank canvas and wire every connection, then change a single value and turn the same graph into image-to-image. What you'll learn: → The 5 core nodes, connected one at a time — checkpoint, CLIP encode, KSampler, empty latent, VAE decode → Why the data flows the way it does, not just where the wires go → Every KSampler setting: seed, steps, CFG, sampler, scheduler → Denoise from 0.9 to 0.0 — the one value that decides how much of your source survives → Locking seeds and generating takes instead of chasing one perfect image → Preview vs. save, and why every image carries the graph that made it → Reopen any result in your asset library as a live workflow → The 6 errors that break Comfy most often → How to read a red node like a sentence Click the links below to run the workflow ⬇️

ComfyUI Tutorial for Beginners: Text-to-Image & Image-to-Image Workflows One graph, two workflows and Module 2 is where you build it node by node instead of loading someone else's. We start from a blank canvas and wire every connection, then change a single value and turn the same graph into image-to-image. What you'll learn: → The 5 core nodes, connected one at a time — checkpoint, CLIP encode, KSampler, empty latent, VAE decode → Why the data flows the way it does, not just where the wires go → Every KSampler setting: seed, steps, CFG, sampler, scheduler → Denoise from 0.9 to 0.0 — the one value that decides how much of your source survives → Locking seeds and generating takes instead of chasing one perfect image → Preview vs. save, and why every image carries the graph that made it → Reopen any result in your asset library as a live workflow → The 6 errors that break Comfy most often → How to read a red node like a sentence Click the links below to run the workflow ⬇️

ComfyUI

60,815 görüntüleme • 1 ay önce

ANTHROPIC LEAKED A 4-AGENT SETUP THAT CUTS A CODEBASE AUDIT FROM 3 DAYS TO 20 MINUTES you point it at a repo and walk away - it comes back with what breaks, ranked, patches already tested. repo → map → 4 auditors → rank → fix → verify → report → back into the map the map cuts the repo by blast radius, not by folder - skip it and four agents audit the same three files and miss the one that ships broken. 4 auditors run in parallel with separate contexts - deps, secrets, dead code, hot paths, and none of them sees another's findings. rank is code, not an agent - sort by what breaks production, drop the duplicates, zero tokens. the fixer only opens patches for the top slice - a hundred findings nobody acts on is a report, not an audit. verify runs the suite on every patch and red goes back to the fixer - that patch only, never the whole batch. the back edge into the map is the whole trick - accepted findings become rules, so next week starts where this one ended. one human step in all of it: which fixes ship - 20 minutes instead of 3 days. save this and read the full graph engineering course below ↓

ANTHROPIC LEAKED A 4-AGENT SETUP THAT CUTS A CODEBASE AUDIT FROM 3 DAYS TO 20 MINUTES you point it at a repo and walk away - it comes back with what breaks, ranked, patches already tested. repo → map → 4 auditors → rank → fix → verify → report → back into the map the map cuts the repo by blast radius, not by folder - skip it and four agents audit the same three files and miss the one that ships broken. 4 auditors run in parallel with separate contexts - deps, secrets, dead code, hot paths, and none of them sees another's findings. rank is code, not an agent - sort by what breaks production, drop the duplicates, zero tokens. the fixer only opens patches for the top slice - a hundred findings nobody acts on is a report, not an audit. verify runs the suite on every patch and red goes back to the fixer - that patch only, never the whole batch. the back edge into the map is the whole trick - accepted findings become rules, so next week starts where this one ended. one human step in all of it: which fixes ship - 20 minutes instead of 3 days. save this and read the full graph engineering course below ↓

Hanako

137,040 görüntüleme • 2 ay önce

IF YOU ARE STILL PROMPTING BY HAND IN 2026 YOU ARE ALREADY BEHIND the guy who built Claude Code at Anthropic said he stopped writing prompts a long time ago he runs loops instead, systems that write the prompts for him and keep working while he sleeps you type one request at a time and wait for the answer he built a machine that fires hundreds of requests, checks its own output and fixes itself with no hands on the keyboard here is how you make the jump step 1 stop treating the model like a chat box and start treating it like a worker you manage step 2 write a loop that takes a goal, breaks it into tasks and sends each one to the model on its own step 3 add a second pass where the model grades its own work and retries whatever failed step 4 let it run on a timer so it keeps shipping while you are away from the screen the person still typing prompts one by one is doing the work of a intern the person running loops is doing the work of a whole team off one laptop prompting was never the skill, building the system that prompts for you is

IF YOU ARE STILL PROMPTING BY HAND IN 2026 YOU ARE ALREADY BEHIND the guy who built Claude Code at Anthropic said he stopped writing prompts a long time ago he runs loops instead, systems that write the prompts for him and keep working while he sleeps you type one request at a time and wait for the answer he built a machine that fires hundreds of requests, checks its own output and fixes itself with no hands on the keyboard here is how you make the jump step 1 stop treating the model like a chat box and start treating it like a worker you manage step 2 write a loop that takes a goal, breaks it into tasks and sends each one to the model on its own step 3 add a second pass where the model grades its own work and retries whatever failed step 4 let it run on a timer so it keeps shipping while you are away from the screen the person still typing prompts one by one is doing the work of a intern the person running loops is doing the work of a whole team off one laptop prompting was never the skill, building the system that prompts for you is

Atlas

16,641 görüntüleme • 2 ay önce

Robinhood gives you a buy button. $GE gives you the thing that does the work after you press it. Four nodes, one rule: nothing ships until the graph breaks it first. Here's where the build actually is. It starts from the opposite idea of every token on the timeline. Those launch a chart and promise a product. This one launched a product and let the chart catch up. Four nodes, running now: > SITE - live, mesh you can spin, terminal rendering cost per answer > GROK - wired into the site, reads the graph and answers on top of it > LADDER - top 10 wallets locked every 10 days, points on the snapshot > DROP - those points settle into the airdrop later Three nodes run. One decides who gets paid. Holding isn't a bet here. It's a position on the leaderboard that compounds every cycle. Since the bond filled we've cleared 60k mcap and moved to PumpSwap. No callers, no paid rooms. Every update shipped the day it was promised. Everyone else sells you the ticker and builds later. We shipped the graph, then the site, then the rewards - in that order. That order is the whole thesis. LET’S MAKE $GE ON ROBINHOOD GREAT AGAIN

Robinhood gives you a buy button. $GE gives you the thing that does the work after you press it. Four nodes, one rule: nothing ships until the graph breaks it first. Here's where the build actually is. It starts from the opposite idea of every token on the timeline. Those launch a chart and promise a product. This one launched a product and let the chart catch up. Four nodes, running now: > SITE - live, mesh you can spin, terminal rendering cost per answer > GROK - wired into the site, reads the graph and answers on top of it > LADDER - top 10 wallets locked every 10 days, points on the snapshot > DROP - those points settle into the airdrop later Three nodes run. One decides who gets paid. Holding isn't a bet here. It's a position on the leaderboard that compounds every cycle. Since the bond filled we've cleared 60k mcap and moved to PumpSwap. No callers, no paid rooms. Every update shipped the day it was promised. Everyone else sells you the ticker and builds later. We shipped the graph, then the site, then the rewards - in that order. That order is the whole thesis. LET’S MAKE $GE ON ROBINHOOD GREAT AGAIN

wast3

10,853 görüntüleme • 1 ay önce