Video wird geladen...

Video konnte nicht geladen werden

Beim Laden dieses Videos ist ein Problem aufgetreten. Dies könnte an einem vorübergehenden Netzwerkproblem liegen oder das Video ist möglicherweise nicht verfügbar.

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 ↓show more

Hanako

17,545 subscribers

16,810 Aufrufe • vor 1 Monat •via X (Twitter)

Wissenschaft & Technologie Bildung

Anya Rossi• Live Now

Private livecam show

6 Kommentare

Profilbild von rewind

rewindvor 1 Monat

So true

Profilbild von slash1s

slash1svor 1 Monat

good vs here

Profilbild von Joel Citron 🟦

Joel Citron 🟦vor 1 Monat

My constraint is I do not have time to babysit every green run while managing the team — and the ones that never page are the ones that burn me. We had a fixed eight-box path that looked rock solid for months until I noticed only three boxes ever fired and a wrong route still came back looking like success. How are you actually measuring route diversity so the tests are not just redrawing the same diagram?

Profilbild von ∑: Meww ∑: (❖,❖)

∑: Meww ∑: (❖,❖)vor 1 Monat

Excellent explanation of workflow versus graph engineering.

Profilbild von Hans “mostly peaceful” Johnson

Hans “mostly peaceful” Johnsonvor 1 Monat

Great article but it’s still just a workflow, lots of variations don’t change that. Dynamic vs static workflow.

Profilbild von Leliu

Leliuvor 1 Monat

This explanation clearly defines workflow limitations and graph engineering advantages.

Ähnliche Videos

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,848 Aufrufe • vor 2 Monaten

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 ↓

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 Aufrufe • vor 2 Monaten

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 Aufrufe • vor 1 Monat

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 ↓

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

97,154 Aufrufe • vor 2 Monaten

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 ↓

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

129,105 Aufrufe • vor 2 Monaten

Loops vs. Graphs, clearly explained! loops are great, and the ceiling is one you can watch turn: a loop is a gear. it produces, checks, corrects, and comes back around. after six turns you have one job, done very well. after six hundred turns you still have one job, done very well. the teeth are perfect. they are touching nothing. Graph engineering fixes this by moving the decision up a layer: not how well one gear turns, but what it is meshed into. 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 turning 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. ↳ 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 ↓

Loops vs. Graphs, clearly explained! loops are great, and the ceiling is one you can watch turn: a loop is a gear. it produces, checks, corrects, and comes back around. after six turns you have one job, done very well. after six hundred turns you still have one job, done very well. the teeth are perfect. they are touching nothing. Graph engineering fixes this by moving the decision up a layer: not how well one gear turns, but what it is meshed into. 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 turning 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. ↳ 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

32,807 Aufrufe • vor 1 Monat

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,225 Aufrufe • vor 2 Monaten

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 ↓

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 Aufrufe • vor 2 Monaten

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

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 Aufrufe • vor 3 Monaten

THIS IS F*CKING OBSCENE opus 5.5 got Fortnite running inside Minecraft and Minecraft running inside GTA 5, with nobody's permission and nobody's documentation three engines, three completely different ways in, and one of them has no way in at all THREE GAMES, THREE DIFFERENT WAYS IN → Minecraft is Java and ships a loader on purpose. that one is the front door. you write against an interface somebody meant for you to use → GTA 5 has no modding api and no front door. you get a compiled binary and nothing else, and the only route in is to read it → Fortnite is a live service with anti cheat sitting on top. there is no way in at all, and that single fact changes the entire job WHAT READING A BINARY ACTUALLY MEANS → no source, no comments, no function names. you recover what code does from what it is, which is the opposite direction from how it was written → the exact build gets pinned before anything else, because one patch moves every address underneath you, and a different version is a different game → nothing counts until it is confirmed inside the running process. launch it, play it, look at it. opus 5.5 does the reading, the pinning and the checking, and that loop is the part that used to be a team and a year WHAT THIS ACTUALLY CHANGES → reverse engineering was the most expensive skill in modding. one person, one binary, months of evenings, and the knowledge died with the project → now it is a loop that runs while you sleep, and what comes out of it is not a guess, it is something that got checked against the game while the game was running → so the hard question stopped being whether you can get into an engine. it is what you do once you are standing in three of them at once one layer was read out of a binary one came through the front door one was never touched at all, and it still had to land right

THIS IS F*CKING OBSCENE opus 5.5 got Fortnite running inside Minecraft and Minecraft running inside GTA 5, with nobody's permission and nobody's documentation three engines, three completely different ways in, and one of them has no way in at all THREE GAMES, THREE DIFFERENT WAYS IN → Minecraft is Java and ships a loader on purpose. that one is the front door. you write against an interface somebody meant for you to use → GTA 5 has no modding api and no front door. you get a compiled binary and nothing else, and the only route in is to read it → Fortnite is a live service with anti cheat sitting on top. there is no way in at all, and that single fact changes the entire job WHAT READING A BINARY ACTUALLY MEANS → no source, no comments, no function names. you recover what code does from what it is, which is the opposite direction from how it was written → the exact build gets pinned before anything else, because one patch moves every address underneath you, and a different version is a different game → nothing counts until it is confirmed inside the running process. launch it, play it, look at it. opus 5.5 does the reading, the pinning and the checking, and that loop is the part that used to be a team and a year WHAT THIS ACTUALLY CHANGES → reverse engineering was the most expensive skill in modding. one person, one binary, months of evenings, and the knowledge died with the project → now it is a loop that runs while you sleep, and what comes out of it is not a guess, it is something that got checked against the game while the game was running → so the hard question stopped being whether you can get into an engine. it is what you do once you are standing in three of them at once one layer was read out of a binary one came through the front door one was never touched at all, and it still had to land right

Roxx

195,977 Aufrufe • vor 24 Tagen

Anthropic engineer: "At Anthropic, all of our engineers are running hundreds of agents The way you do it is graph engineering" In just 36 minutes, he shows how Anthropic runs hundreds of agents at once and what actually makes it possible Prompts → Agents → Loops → Graphs The part most people skip is the return path, where every accepted result becomes a constraint for the next run Same model, same tokens, completely different system Prompting is the old workflow Graph engineering is the next one Watch it today Then save the full graph engineering guide below before everyone starts catching up ↓

Anthropic engineer: "At Anthropic, all of our engineers are running hundreds of agents The way you do it is graph engineering" In just 36 minutes, he shows how Anthropic runs hundreds of agents at once and what actually makes it possible Prompts → Agents → Loops → Graphs The part most people skip is the return path, where every accepted result becomes a constraint for the next run Same model, same tokens, completely different system Prompting is the old workflow Graph engineering is the next one Watch it today Then save the full graph engineering guide below before everyone starts catching up ↓

Lunar

32,987 Aufrufe • vor 2 Monaten

you numbered the steps so it could not get lost it does not get lost that list was written for a model that wandered, and this one plans better than the list does, so every number you added is a place where it is no longer allowed, to be smarter than you state the goal, the constraints, and how you will know it worked keep the numbers only where exactly one sequence is safe, which is deletes, auth and compliance the procedure felt like rigour it is a cage built to the dimensions of a model that is not in the room

you numbered the steps so it could not get lost it does not get lost that list was written for a model that wandered, and this one plans better than the list does, so every number you added is a place where it is no longer allowed, to be smarter than you state the goal, the constraints, and how you will know it worked keep the numbers only where exactly one sequence is safe, which is deletes, auth and compliance the procedure felt like rigour it is a cage built to the dimensions of a model that is not in the room

Lagosaur

14,857 Aufrufe • vor 2 Monaten

your agent reviewing its own work is not a check. it is a second opinion from the same source. this is the most common gap in agent systems and it hides in plain sight, because the step exists. there is a review. it just cannot do the thing you think it does. here is the mechanism. the model produced an output from a context. you then ask the same model, holding the same context, whether that output is correct. it answers fluently, because that is what it does. and the answer is drawn from the same distribution that produced the thing being judged. same weights, same window, same blind spots. if the reason the output is wrong is something the model does not know, the review does not know it either. if the reason is something the context does not contain, the review has the same context. the failure mode and the detector share a cause. > why it feels like it works because most of the time the output is fine, and the review says fine. agreement is not evidence of detection. a reviewer that says pass on everything agrees with reality most of the time too. what you actually want to measure is what happens on the cases that are wrong. that is the only place a check earns its name, and it is exactly the place where a self-review is weakest. there is research on this. Huang and colleagues at DeepMind showed at ICLR 2024 that intrinsic self-correction, revising without external grounding, does not reliably help and often makes things worse. > what to actually do move the check outside the model. a test that runs, a schema that validates, a file that exists or does not, an exit code from something you did not write. these are not smarter than the model. they are just not correlated with it, and that is the entire value. when the judgement genuinely needs a model, at minimum use a different family. same family means shared blind spots, and frontier judges measurably inflate scores for outputs that look like their own. and split the work by kind. anything objectively checkable goes to code. only the genuinely semantic calls go to a judge, and those get a rubric written as one line. a review inside the loop tells you the model is confident. a check outside it tells you whether the work is done. save this - then read the eval setup below

your agent reviewing its own work is not a check. it is a second opinion from the same source. this is the most common gap in agent systems and it hides in plain sight, because the step exists. there is a review. it just cannot do the thing you think it does. here is the mechanism. the model produced an output from a context. you then ask the same model, holding the same context, whether that output is correct. it answers fluently, because that is what it does. and the answer is drawn from the same distribution that produced the thing being judged. same weights, same window, same blind spots. if the reason the output is wrong is something the model does not know, the review does not know it either. if the reason is something the context does not contain, the review has the same context. the failure mode and the detector share a cause. > why it feels like it works because most of the time the output is fine, and the review says fine. agreement is not evidence of detection. a reviewer that says pass on everything agrees with reality most of the time too. what you actually want to measure is what happens on the cases that are wrong. that is the only place a check earns its name, and it is exactly the place where a self-review is weakest. there is research on this. Huang and colleagues at DeepMind showed at ICLR 2024 that intrinsic self-correction, revising without external grounding, does not reliably help and often makes things worse. > what to actually do move the check outside the model. a test that runs, a schema that validates, a file that exists or does not, an exit code from something you did not write. these are not smarter than the model. they are just not correlated with it, and that is the entire value. when the judgement genuinely needs a model, at minimum use a different family. same family means shared blind spots, and frontier judges measurably inflate scores for outputs that look like their own. and split the work by kind. anything objectively checkable goes to code. only the genuinely semantic calls go to a judge, and those get a rubric written as one line. a review inside the loop tells you the model is confident. a check outside it tells you whether the work is done. save this - then read the eval setup below

Hanako

14,325 Aufrufe • vor 3 Monaten

The Matrix is not a documentary. It is not a leaked manual. It is not proof that you live in a pod, that the world is fake, that nothing matters. That is the trap the story itself warns you about: Confusing the map for the territory, the metaphor for the mechanism. The true reality: The Matrix is a mirror disguised as a movie. It is Plato's cave in leather. It is the Gnostic dream in green code. It is the oldest story humanity tells: That you are asleep, that the world you take for granted is a consensus trance, and that waking is possible, but not free. The "matrix" is not a machine. It is a set of agreements. It is the inherited assumptions you never chose: That you are your job, your bank balance, your diagnosis, your past. That happiness is purchased. That time is scarce. That you are separate from the earth, from each other, from Source. These are not truths. They are programs. And they run quietly, in the background, until you notice them. There are levels. The obvious one: Media, money, empire, the stories told to keep you consuming and afraid. The subtler one: Language itself. The words you think in shape what you can perceive. The deepest one: The illusion of the separate self, the belief that there is someone in here looking out at a world out there. That is the root program. Dissolve it, and the rest loosens. But here is the hard teaching the film got right: You cannot unplug someone by force. The red pill is offered, never imposed. Free will is the architecture. And the red pill is not escape. It is responsibility. Neo does not wake up into paradise. He wakes up into a ruined world, a hard road, and a body that hurts. Freedom is not comfort. It is agency. And the film got something else right: The Matrix is not only out there. It is in you. Your habits. Your fears. Your addictions to certainty and outrage. Your need to be right. The agents are not only suits chasing you. They are the thoughts that police your aliveness. The prison is internal before it is external. That is why no external savior can free you. The One is not a person you wait for. It is what you are when you stop outsourcing your authority. There is no spoon. There is no fixed reality to fight. There is relationship, attention, and choice. You do not destroy the illusion. You stop being ruled by it. You bend, not the world, but your relationship to it. That is the bending of the spoon. Beware the counterfeit awakening. There are those who will sell you the red pill as a product, a course, a supplement, a secret doctrine, a political savior. That is the Matrix wearing a red coat. True waking does not make you superior. It makes you humble, kind, and unafraid. It does not make you hate the sleepers. It makes you patient with them, because you remember you were one. The deepest truth: The Matrix is not a place you escape. It is a dream you stop confusing with the whole of yourself. You are not the character. You are not even the actor. You are the awareness in which the whole film plays. When you know that, you can walk inside the illusion without being owned by it, free, present, and quietly sovereign. So take the red pill. But understand what it is: Not a fact, but a commitment. Not information, but transformation. Not escape from the world, but awakening within it. The door has always been open. You were just looking for it in the wrong place.

The Matrix is not a documentary. It is not a leaked manual. It is not proof that you live in a pod, that the world is fake, that nothing matters. That is the trap the story itself warns you about: Confusing the map for the territory, the metaphor for the mechanism. The true reality: The Matrix is a mirror disguised as a movie. It is Plato's cave in leather. It is the Gnostic dream in green code. It is the oldest story humanity tells: That you are asleep, that the world you take for granted is a consensus trance, and that waking is possible, but not free. The "matrix" is not a machine. It is a set of agreements. It is the inherited assumptions you never chose: That you are your job, your bank balance, your diagnosis, your past. That happiness is purchased. That time is scarce. That you are separate from the earth, from each other, from Source. These are not truths. They are programs. And they run quietly, in the background, until you notice them. There are levels. The obvious one: Media, money, empire, the stories told to keep you consuming and afraid. The subtler one: Language itself. The words you think in shape what you can perceive. The deepest one: The illusion of the separate self, the belief that there is someone in here looking out at a world out there. That is the root program. Dissolve it, and the rest loosens. But here is the hard teaching the film got right: You cannot unplug someone by force. The red pill is offered, never imposed. Free will is the architecture. And the red pill is not escape. It is responsibility. Neo does not wake up into paradise. He wakes up into a ruined world, a hard road, and a body that hurts. Freedom is not comfort. It is agency. And the film got something else right: The Matrix is not only out there. It is in you. Your habits. Your fears. Your addictions to certainty and outrage. Your need to be right. The agents are not only suits chasing you. They are the thoughts that police your aliveness. The prison is internal before it is external. That is why no external savior can free you. The One is not a person you wait for. It is what you are when you stop outsourcing your authority. There is no spoon. There is no fixed reality to fight. There is relationship, attention, and choice. You do not destroy the illusion. You stop being ruled by it. You bend, not the world, but your relationship to it. That is the bending of the spoon. Beware the counterfeit awakening. There are those who will sell you the red pill as a product, a course, a supplement, a secret doctrine, a political savior. That is the Matrix wearing a red coat. True waking does not make you superior. It makes you humble, kind, and unafraid. It does not make you hate the sleepers. It makes you patient with them, because you remember you were one. The deepest truth: The Matrix is not a place you escape. It is a dream you stop confusing with the whole of yourself. You are not the character. You are not even the actor. You are the awareness in which the whole film plays. When you know that, you can walk inside the illusion without being owned by it, free, present, and quietly sovereign. So take the red pill. But understand what it is: Not a fact, but a commitment. Not information, but transformation. Not escape from the world, but awakening within it. The door has always been open. You were just looking for it in the wrong place.

Ra 𐦝

58,824 Aufrufe • vor 1 Monat

you wrote a long careful note so it would remember the thing properly the note is the part that does not load what loads at the start of every session is the index line, the one sentence summary, and only the first two hundred lines of it or the first twenty five kilobytes, whichever runs out first the topic files underneath are read on demand, which means only if something in that one line makes it go and open them i checked mine: thirty nine index lines loading every session, thirty nine topic files loading none of the time the detail you were careful about is not context it is a footnote your agent has to choose to open and the sentence you dashed off in three seconds is the whole memory

you wrote a long careful note so it would remember the thing properly the note is the part that does not load what loads at the start of every session is the index line, the one sentence summary, and only the first two hundred lines of it or the first twenty five kilobytes, whichever runs out first the topic files underneath are read on demand, which means only if something in that one line makes it go and open them i checked mine: thirty nine index lines loading every session, thirty nine topic files loading none of the time the detail you were careful about is not context it is a footnote your agent has to choose to open and the sentence you dashed off in three seconds is the whole memory

Lagosaur

28,369 Aufrufe • vor 2 Monaten

this video is the CLEAREST explanation of how claude skills + AI agents work and how to use them most people set up an AI agent and wonder why it keeps disappointing them. the context window is everything context is what the model assembles before it takes any action. think of it like everything the agent needs to read before it does anything. the quality of what goes in determines the quality of what comes out. the models are genuinely really good right now. claude and gpt are exceptional. the variable is almost always the context you give them. 1. agent.md files are mostly unnecessary every single line you put in an agent.md file gets added to every single conversation you have with your agent. a 1000 line file is around 7000 tokens burning on every run. the model already knows to use react. it can read your codebase. save the agent.md for proprietary information specific to your company that the model genuinely cannot know on its own. 2. skills are the actual unlock a skill.md file works differently. what loads into context is only the name and description, around 50 tokens. the full instructions only appear when the agent recognizes it needs that skill. so instead of 7000 tokens on every run you have 50. and the agent stays sharp because the context window stays lean. the closer you get to filling the context window the worse the agent performs, same way you perform worse when someone dumps 10 things on you at once. 3. here is how to actually build a skill the right way most people identify a workflow and immediately try to write the skill. what you want to do instead is run the workflow by hand with the agent first. walk it through every single step. tell it what to check, what good looks like, what bad looks like. correct it in real time. once you have had a full successful run from start to finish, tell the agent to review everything it just did and write the skill itself. it writes a better skill than you will because it has the full context of what actually worked in practice not in theory. 4. recursively building skills is how you go from frustrated to reliable when the skill breaks, and it will break, ask the agent exactly why it failed. it will tell you specifically what went wrong. fix it together in that same conversation. then tell it to update the skill file so that failure mode never happens again. ross mike did this five times with his youtube report generator. it now pulls from eight different data sources and runs flawlessly every single time without him touching it. 5. sub agents are something you earn not something you set up on day one start with one agent. build one workflow. turn it into one skill. once that works add another. ross mike has five sub agents now covering marketing, business, personal and more. it took months to get there and every single one exists because a workflow proved it deserved to exist. the people who set up 15 sub agents on day one and wonder why nothing works skipped all the steps that make the thing actually run. 6. your workflow is the thing the model cannot get anywhere else the model has been trained on everything. it knows more than you about most things. what it does not have is your specific process, your taste, your way of doing things. that is what skills capture. that is what makes your agent actually useful versus a generic one. downloading someone else's skill means downloading their context onto your setup and it will not work the way you want it to because it was never built around how you work. this is the clearest explanation of how agents actually work i have heard. Micky runs this stuff every single day and the results show it. full episode is now live on The Startup Ideas Podcast (SIP) 🧃 where you get your pods people charge for this sorta stuff i give away the sauce for free i just want you to win watch

this video is the CLEAREST explanation of how claude skills + AI agents work and how to use them most people set up an AI agent and wonder why it keeps disappointing them. the context window is everything context is what the model assembles before it takes any action. think of it like everything the agent needs to read before it does anything. the quality of what goes in determines the quality of what comes out. the models are genuinely really good right now. claude and gpt are exceptional. the variable is almost always the context you give them. 1. agent.md files are mostly unnecessary every single line you put in an agent.md file gets added to every single conversation you have with your agent. a 1000 line file is around 7000 tokens burning on every run. the model already knows to use react. it can read your codebase. save the agent.md for proprietary information specific to your company that the model genuinely cannot know on its own. 2. skills are the actual unlock a skill.md file works differently. what loads into context is only the name and description, around 50 tokens. the full instructions only appear when the agent recognizes it needs that skill. so instead of 7000 tokens on every run you have 50. and the agent stays sharp because the context window stays lean. the closer you get to filling the context window the worse the agent performs, same way you perform worse when someone dumps 10 things on you at once. 3. here is how to actually build a skill the right way most people identify a workflow and immediately try to write the skill. what you want to do instead is run the workflow by hand with the agent first. walk it through every single step. tell it what to check, what good looks like, what bad looks like. correct it in real time. once you have had a full successful run from start to finish, tell the agent to review everything it just did and write the skill itself. it writes a better skill than you will because it has the full context of what actually worked in practice not in theory. 4. recursively building skills is how you go from frustrated to reliable when the skill breaks, and it will break, ask the agent exactly why it failed. it will tell you specifically what went wrong. fix it together in that same conversation. then tell it to update the skill file so that failure mode never happens again. ross mike did this five times with his youtube report generator. it now pulls from eight different data sources and runs flawlessly every single time without him touching it. 5. sub agents are something you earn not something you set up on day one start with one agent. build one workflow. turn it into one skill. once that works add another. ross mike has five sub agents now covering marketing, business, personal and more. it took months to get there and every single one exists because a workflow proved it deserved to exist. the people who set up 15 sub agents on day one and wonder why nothing works skipped all the steps that make the thing actually run. 6. your workflow is the thing the model cannot get anywhere else the model has been trained on everything. it knows more than you about most things. what it does not have is your specific process, your taste, your way of doing things. that is what skills capture. that is what makes your agent actually useful versus a generic one. downloading someone else's skill means downloading their context onto your setup and it will not work the way you want it to because it was never built around how you work. this is the clearest explanation of how agents actually work i have heard. Micky runs this stuff every single day and the results show it. full episode is now live on The Startup Ideas Podcast (SIP) 🧃 where you get your pods people charge for this sorta stuff i give away the sauce for free i just want you to win watch

GREG ISENBERG

195,059 Aufrufe • vor 7 Monaten

Your faith was forged in people who would rather be exterminated than assimilated. A soft version of it, eager to be liked and desperate to fit in, is not the thing they died to hand you. So stop striving to be liked. Stop angling to be loved by a world that drove your fathers into the snow. That world would think no better of the gospel today than it did in 1838. Stop trying to file down every peculiar and glorious edge of the Restoration until the world finally finds you acceptable. It never will. And the wanting of its approval is the slow death of everything your people bled to preserve. I am thinking of the proclamation on the family, and of how many have quietly gone looking for a way around it. Some say it aloud now. Some march under the world's Pride banners and tell themselves it is only love. They have done the quiet arithmetic and concluded that if they give the world this one doctrine, the world will finally stop hating them, finally let them belong, finally call them good. It does not work that way. It has never once worked that way. Understand what the world actually hates, because it is not a single teaching about marriage that it cannot abide. It is the claim. It is the unbearable, scandalous claim that the keys of the priesthood were restored to the earth, that there is a prophet who speaks for God, that this and no other is the authorized house of the Lord. That is the offense. That is what it cannot forgive. You could surrender every doctrine the world finds distasteful, one after another, and you would not buy a single hour of peace, because the thing it objects to is not your position on this or that. It is that you claim to hold the authority of heaven, and it intends to see that claim humbled. The doctrine is only the doorway it is pushing on. The house is what it wants. Embrace the truth. Embrace the battle that has always come with it, because there has always been a battle, and there is one now. It is the oldest war there is, good against evil, light against the dark, and you were born onto its field whether you wished to be or not. You did not inherit a museum. You inherited a war, and a banner, and a people who never once surrendered it. You are a Mormon. The blood of the persecuted is in you, and the truth they died for is in your hands. You are not tourists. You are not spectators. You are the heirs of warriors, and the line they held is now yours to hold. So plant your feet on the ground they bled for. Lift the banner they would not drop.

Your faith was forged in people who would rather be exterminated than assimilated. A soft version of it, eager to be liked and desperate to fit in, is not the thing they died to hand you. So stop striving to be liked. Stop angling to be loved by a world that drove your fathers into the snow. That world would think no better of the gospel today than it did in 1838. Stop trying to file down every peculiar and glorious edge of the Restoration until the world finally finds you acceptable. It never will. And the wanting of its approval is the slow death of everything your people bled to preserve. I am thinking of the proclamation on the family, and of how many have quietly gone looking for a way around it. Some say it aloud now. Some march under the world's Pride banners and tell themselves it is only love. They have done the quiet arithmetic and concluded that if they give the world this one doctrine, the world will finally stop hating them, finally let them belong, finally call them good. It does not work that way. It has never once worked that way. Understand what the world actually hates, because it is not a single teaching about marriage that it cannot abide. It is the claim. It is the unbearable, scandalous claim that the keys of the priesthood were restored to the earth, that there is a prophet who speaks for God, that this and no other is the authorized house of the Lord. That is the offense. That is what it cannot forgive. You could surrender every doctrine the world finds distasteful, one after another, and you would not buy a single hour of peace, because the thing it objects to is not your position on this or that. It is that you claim to hold the authority of heaven, and it intends to see that claim humbled. The doctrine is only the doorway it is pushing on. The house is what it wants. Embrace the truth. Embrace the battle that has always come with it, because there has always been a battle, and there is one now. It is the oldest war there is, good against evil, light against the dark, and you were born onto its field whether you wished to be or not. You did not inherit a museum. You inherited a war, and a banner, and a people who never once surrendered it. You are a Mormon. The blood of the persecuted is in you, and the truth they died for is in your hands. You are not tourists. You are not spectators. You are the heirs of warriors, and the line they held is now yours to hold. So plant your feet on the ground they bled for. Lift the banner they would not drop.

Kirk Rollins

30,673 Aufrufe • vor 4 Monaten

Opus 5.5 opens someone else’s .blend file and tells you exactly how they got the result you’ve been failing to copy for a week. Every artist has that folder: downloaded scenes, studio files, asset packs. You open them, poke at the node tree, and still cannot say why it looks right. The file is not hiding anything. It is just that a finished scene has no record of the order its decisions were made in. > TRACE - the node graph read as a sequence, not a picture > WHY - each modifier tied to the problem it solves > SKIP - defaults left untouched, so you see what was deliberate > COPY - the technique isolated from the artwork around it That third one is the useful part. In most scenes nine settings out of ten were never changed, and the five that were carry the entire look. Tutorials never show you that split. They walk you through every click, including the ones that did nothing. What comes back is not the file. It is the reasoning that produced it, written as steps you can apply to your own geometry. Nobody learns Blender from documentation. They learn it by taking apart work that already works, and that teardown has always been manual. The full teardown of one scene, node by node, is in the article below ↓

Opus 5.5 opens someone else’s .blend file and tells you exactly how they got the result you’ve been failing to copy for a week. Every artist has that folder: downloaded scenes, studio files, asset packs. You open them, poke at the node tree, and still cannot say why it looks right. The file is not hiding anything. It is just that a finished scene has no record of the order its decisions were made in. > TRACE - the node graph read as a sequence, not a picture > WHY - each modifier tied to the problem it solves > SKIP - defaults left untouched, so you see what was deliberate > COPY - the technique isolated from the artwork around it That third one is the useful part. In most scenes nine settings out of ten were never changed, and the five that were carry the entire look. Tutorials never show you that split. They walk you through every click, including the ones that did nothing. What comes back is not the file. It is the reasoning that produced it, written as steps you can apply to your own geometry. Nobody learns Blender from documentation. They learn it by taking apart work that already works, and that teardown has always been manual. The full teardown of one scene, node by node, is in the article below ↓

wast3

16,237 Aufrufe • vor 18 Tagen

A 250-pound wild animal just walked through a parking lot full of strangers, ignored every rule it was born with, and did something that should be biologically impossible. Nobody screamed. Nobody ran. Nobody reached for a phone fast enough. Except one person. And that one person is the reason you are reading this. Before I tell you why this clip is going to wreck your afternoon, I need you to understand one thing: this was not a petting zoo. This was not a farm. This was not a trained animal with a handler hiding behind a bush. This was a Tuesday-evening parking lot. Asphalt. Painted white lines. Open car doors. Somebody's groceries still in the trunk. And a wild buck with a full set of antlers decided the safest place in the entire valley was right next to us. Read that again. Then keep reading, because the part that made me stop scrolling is not the animal. It's what the human did next. THE RULE EVERY WILD ANIMAL FOLLOWS (UNTIL THIS ONE DIDN'T) Here is the deal every deer on Earth signs at birth. Rule one: humans are predators. Rule two: predators are to be avoided at a distance of at least a hundred yards. Rule three: if rules one and two fail, run, and ask questions never. A deer that breaks those rules does not get to pass its genes along. That is not poetry. That is the math of survival. For about ten million years, the deer that stayed wary lived, and the deer that got curious became dinner. So when you see a mature buck, with a rack that took an entire summer to grow, walk across open pavement toward a human being, you are not watching a cute moment. You are watching a hundred-million-dollar evolutionary security system get overridden in real time. Something switched off. And I want to know what. Because here is what the biologists will tell you: wild animals do not walk up to people by accident. They calculate. Every step. Every ear flick. Every pause. A deer's entire life is a risk assessment that never stops running, not even when it sleeps. This one ran the numbers. And the numbers said: go. That is the first thing that should bother you. The second thing is worse. WHAT A MULE DEER SEES THAT YOU DON'T Let's talk about the animal itself, because most people have no idea what they are looking at. This is a mule deer. Not the white-tailed deer from your grandmother's backyard that eats her tulips. Mule deer are the big-country cousin. The western ones. The ones that live where the land is steep, dry, and unforgiving. They are named for the ears. Enormous, mule-sized ears that swivel independently, like two satellite dishes aimed at different threats at the same time. One ear can be tracking a car door slamming while the other is tracking a branch snapping a hundred feet behind it. Think about that. While you were reading this sentence, a mule deer would have processed about forty things you never noticed. Their antlers are a different story entirely. Mule deer antlers do not grow like a hat rack, with one main beam and short spikes. They fork. Then they fork again. Every branch splits into two, like a river delta made of bone. Biologists call it dichotomous branching, and it is one of the fastest ways to tell a mule deer from any other deer in North America. And here is the part that gets me every time. That entire rack, the weight, the bone, the symmetry, grows back from scratch every single year. It falls off in winter. It regrows in spring. By late summer it is a fully hardened weapon, and the velvet that fed it peels off in strips. Antlers are one of the fastest-growing tissues in the entire mammal kingdom. A living thing is building bone faster than almost anything else on the planet, and it does it every year, on a diet of grass, shrubs, and whatever it can find. Now picture the animal carrying all that, taking a slow, deliberate stroll through a place built entirely for humans. You would expect panic. You would expect the sprint. Mule deer do not run like other deer. They bounce. It is called stotting, all four hooves hitting the ground and launching off at the same time, like four pogo sticks fused together. It lets them take off uphill, over rocks, over fences, at speeds past thirty-five miles an hour. This animal could have been gone in two seconds. It chose not to be. THE PARKING LOT NOBODY WARNED YOU ABOUT I need to explain something about the setting, because it changes everything. A parking lot is the single most hostile environment a wild deer can walk into. It has no cover. It has no escape routes. It has hard surfaces that echo every sound. It has engines, doors, keys, and sudden movements from every angle. It smells like exhaust, oil, rubber, perfume, fast food, and sunscreen. Every instinct a deer owns says: do not go there. And yet they do. More and more of them. In towns across the West, deer have learned that the same open space that feels dangerous also has something they cannot find in the wild: reliable, concentrated minerals. Salt, in particular. Which brings me to the secret that explains half the strange deer behavior you will ever see. DEER ARE ADDICTED TO SALT, AND YOU ARE COVERED IN IT Wild deer are chronically short on sodium. The plants they eat are rich in potassium and poor in salt, which means their bodies are constantly hunting for it, the way you would hunt for water in a desert. That craving is so strong that deer will travel miles for a salt lick. They will chew on road shoulders that were salted for winter ice. They will lick rocks, soil, cattle blocks, and, yes, the sweaty palm of a stranger. Your skin is a salt block with a pulse. Sweat is salty. Sunscreen is salty. Hand lotion is salty. The residue left on a car door handle from a thousand different hands is salty. And a deer's nose is roughly fifty times more sensitive than yours, which means that where you smell nothing, it smells a buffet. So when a deer walks up to a person and licks them, the cute story is: it trusts you. The honest story is: it has just identified you as a resource. And that is where this gets interesting, because both of those stories can be true at once. And the gap between them is exactly where the danger lives. I will get to that. But first I want to talk about the October problem. WHY THIS HAPPENED NOW, IN THIS EXACT WEEK Timing matters. This was not shot in June. This was shot in the weeks leading up to the rut. The rut is the mating season, and for mule deer it kicks into gear in the late fall. In the weeks before it, a buck's body becomes a chemistry experiment. Testosterone surges. The neck swells to nearly twice its normal width. Appetite explodes, then collapses. Bucks that spent the summer in friendly bachelor groups start sizing each other up like boxers at a weigh-in. And here is the part nobody puts in the viral captions: bucks in the pre-rut and rut do strange things. They stop eating normally. They stop sleeping normally. They take risks they would never take in July. They cross highways. They chase. They ignore threats they would normally flee from. Sometimes that makes them aggressive. Sometimes it makes them bold in a calm, almost dreamy way, drifting through human spaces like they have somewhere to be and nobody on Earth will stop them. Wildlife officers across the country put out the same warning every fall: the most dangerous time to be near a deer is the exact time they look the most relaxed around you. Hold that thought. Because the clip you are about to watch lives right on that line. THE MOMENT THAT BROKE THE INTERNET'S BRAIN I have been posting on this platform for over a decade. I have watched thousands of animal videos. I know what a staged one looks like. I know what an edited one looks like. I know what a clip looks like when somebody has been feeding the animal for three weeks and is milking it for views. This is not that. What makes this different is the absence of anything staged. There is no music cue. There is no hero shot. The camera is not steady. The person filming is clearly not planning anything. The deer is not being led, called, baited, or coaxed. It is just there. And the people near it do the one thing nobody expects: they let it be. If you have ever tried to take a photo of a wild animal, you know how rare that is. The first instinct of almost every human is to move closer, reach, wave, call out, make noise. We cannot help ourselves. We are the most invasive species on the planet, and we think of ourselves as the gentle ones. Not here. Here, someone stood still. STILLNESS IS THE MOST POWERFUL THING A HUMAN CAN DO This is going to sound like a TED Talk, and I do not care. In the wild, the single most reliable signal of safety is stillness. Think about it from the deer's point of view. Predators move. Wolves, cougars, coyotes, they stalk, they creep, they accelerate. A thing that is standing completely still, with soft posture, no direct stare, and no sudden hand motions, is statistically not hunting. Hunters know this. Photographers know this. Anyone who has ever sat motionless in a blind for six hours and watched an entire forest go back to normal around them knows this. When you stop moving, the world forgets you are a threat. That is the entire secret. It is not magic. It is not a special bond. It is not some gift a few people have. It is patience, expressed as a body. And it is so rare that when we see it, we film it, and then we pass it around like a miracle. I want you to sit with that for a second. We are so unused to calm that watching one person stay calm near a wild animal feels like footage of something supernatural. Maybe that is why this clip is going the way it is going. Maybe it is not really about the deer. THE THING YOU ARE NOT SUPPOSED TO DO (AND WHY I NEED TO SAY IT) Now I am going to be the bad guy for a minute, and I am going to do it because I would rather annoy you today than see a headline about you tomorrow. Do not feed wild deer. Not apples. Not carrots. Not crackers. Not that sad half-sandwich you are not going to finish. Not anything. It is illegal in many states, and the fines are real. But the law is not even the main reason. The main reason is what feeding does to the animal. A deer that gets fed by humans learns one lesson, and it learns it fast: people mean food. That lesson is permanent. It does not go away in the winter. It does not go away when the apples run out. It follows that animal to the road, to the neighbor's dog, to the kid with a plate of cookies who does not know better. The next stop in that chain is almost always the same: an animal that is no longer afraid, in a place where fear was the only thing keeping it alive. Biologists have a name for it. Habituation. And in places where it has taken hold, it has produced bucks that charge people over a sandwich, does that stomp dogs to death, and fawns that grow up believing the safest place in the world is a human porch. Every one of those stories ends badly. Almost always for the deer. Wildlife agencies relocate habituated animals only rarely, and relocation often fails. Many are euthanized. A fed deer is, very often, a dead deer, and the person who fed it never finds out. That is the unfair math. The human gets a story. The animal gets the bill. THE INVISIBLE PROBLEM IN A DEER'S MOUTH There is a second reason, and it is the one that makes biologists genuinely lose sleep. It is called chronic wasting disease. CWD is a fatal neurological disease that affects deer, elk, and moose. It is caused by a misfolded protein called a prion, the same class of infectious agent behind mad cow disease. There is no vaccine. There is no cure. Infected animals lose weight, lose coordination, lose fear of humans, and eventually die. It has been found in dozens of states and a growing list of countries. And it spreads in the most ordinary way imaginable: through saliva, urine, feces, and contaminated soil. The prions can persist in the environment for years. Which means that a deer licking something is not a harmless gesture. It is a transfer of material. In one direction or the other. And in places where animals crowd around the same feeding spot, the same hand, the same parking lot, they swap disease the way kids swap germs in a classroom. To date, there has been no confirmed case of CWD infecting a human. Health agencies still recommend not eating meat from infected animals, and they keep monitoring the situation, because prion diseases have a nasty history of surprising us. I am not saying this to ruin a good clip. I am saying it because the same clip that makes your heart melt could also be a warning label for the entire ecosystem, and almost nobody will say that part out loud. So hold both truths. They are both real. WHY YOU CANNOT STOP WATCHING Let me tell you what I think is actually going on in your brain when you watch something like this. Humans are wired for one very specific kind of story: the one where a thing that should be dangerous chooses gentleness. It is the oldest story we have. It is the lion lying down with the lamb. It is the dog who guarded the first fire. It is the wolf who walked toward a campsite twenty thousand years ago and, according to one version of history, became every dog you have ever loved. Every time we see a wild creature step across the line between wild and safe, something ancient in us goes quiet and warm. It feels like being forgiven for something we cannot name. That is why the comment sections under videos like this fill up with the same four words: I need this energy. People are not craving deer. They are craving that feeling of being unafraid and being met with kindness in return. The parking lot is just the stage. And the stage is brilliant, because it is so ordinary. You do not need a mountain. You do not need a safari. You do not need a rare permit. You need a Tuesday, a patch of asphalt, and the willingness to stand still. WHAT THE ANIMAL KNEW THE WHOLE TIME I want to say something about the deer itself, because I think we skip over it. Everything about that animal's body language, in every second of footage, says the same thing: it is paying attention. Not to the camera. Not to the cars. Not to the noise. To the people near it. Look at the ears. Look at where the eyes are pointing. Look at the way the head dips and lifts. That is not an animal in a trance. That is a mind running, carefully, through a list of questions. Is this person tense? Is this person holding anything? Is this person looking directly at me? Is this person moving toward me, or letting me move toward them? Deer read posture the way you read a face. They can tell the difference between a hand that is reaching to grab and a hand that is simply resting. They can tell the difference between a person who wants something and a person who is simply there. And every answer that animal got, in every second, was the same answer: you are fine. That is the story. Not that the deer was tame. That the humans, for those few moments, were safe. THE DEBATE THAT IS ALREADY TEARING THE COMMENTS APART Every clip like this splits the internet into two camps within about ninety seconds. I have seen it a hundred times. Here is what each side says, and I want you to notice that both of them have a point. Camp one: this is beautiful. A wild animal chose peace. A human responded with respect. Nobody got hurt, nobody got chased, nobody got fed, and for forty-eight seconds the world made sense. Let people have one good thing. Camp two: this is a problem dressed as a miracle. Deer in parking lots are deer near traffic. Deer near people are deer that end up in the news for the wrong reasons. Clips like this teach thousands of viewers that walking up to a wild animal is safe, and a few of them will try it with the wrong animal, at the wrong time of year, with the wrong amount of confidence. Both camps are right. That is why the argument never ends. Here is where I land, and you can disagree with me: the clip is not the danger. The lesson people take from the clip is the danger. Watch it as a gift. Do not copy it as a recipe. A wild animal doing something remarkable is not an invitation. It is a moment. And moments do not repeat on command. THE NUMBER THAT SHOULD SCARE YOU MORE THAN ANY ANTLER If you want to know what the real risk around deer is, forget the antlers. Look at the road. In the United States, drivers hit more than a million deer a year. Roughly two hundred people die in those collisions annually, and tens of thousands are injured. The damage runs into the billions. Deer do not understand roads. They understand grass on one side and water on the other. A parking lot is a road with a nicer logo. And here is the brutal part: an animal that has lost its fear of people has also lost its fear of the machines people drive. A deer that walks calmly between parked cars is a deer that will walk calmly in front of a truck. That is not drama. That is the exact reason wildlife managers hate the word cute. So the next time you see a deer standing beside a busy road, calm and curious and apparently unbothered, do not read it as a sign of peace. Read it as a countdown. THE TOWN THAT BECAME A DEER TOWN There is a reason this keeps happening in the same kinds of places. Across the American West, towns have spread into the exact valleys that deer used for winter range. Sidewalks replaced meadows. Lawns replaced native grass. Landscaping replaced sagebrush, and landscaping, it turns out, is delicious. Deer are not invading anything. They are loyal to land that was theirs long before the parking lot was poured. Think about what that means. These animals have been walking the same routes for generations. Their mothers walked them. Their grandmothers walked them. And now those routes pass through a grocery store lot, a gas station, a church, an elementary school. Wildlife biologists call this the urban edge, and it is one of the strangest laboratories on Earth. Deer there live longer, because there are fewer predators. They breed more, because there is more food. They lose their fear, because nothing has hurt them yet. And then something does. Understanding that makes the clip heavier. Because the animal you are about to watch is not a creature of the wild and not a creature of the town. It is something new, shaped by both, and we do not yet have a word for it. THE FIVE-SECOND RULE FOR MEETING A WILD ANIMAL Fine. You are going to see a deer one day. Maybe tonight. Maybe next to your car. What do you do? Here is the short version, straight from the people who do this for a living. One. Stop. Do not rush toward it. Do not wave. Do not call it over. Every second you stay calm is a second the animal stays calm. Two. Give it space. Wildlife agencies generally recommend at least twenty-five yards from deer, elk, and similar large animals. That is about the length of two buses. If you are closer than that and it is approaching you, you are not in charge of the situation anymore. Three. Keep your hands to yourself. No reaching. No offering. No touching. The moment you put a hand toward a wild animal you have stopped being a bystander and started being a variable. Four. Never, ever, feed it. We covered this. It is the single worst thing you can do for the animal. Five. Leave the way you came. Slowly. Do not turn it into a chase. Do not follow for a better angle. Do not crowd it for a photo. That is the whole list. Five rules, all of them free, none of them hard. And almost nobody follows them. WHY THE BEST WILDLIFE FOOTAGE IS ALWAYS ACCIDENTAL I want to tell you something I have learned from a decade of watching content go viral. The best clips are never planned. Not the ones with a million likes. Not the ones with ten million. The ones that stay in your head for a week are almost always filmed by someone who did not know they were filming anything special. Because planning kills the thing we are actually watching for: the unscripted instant when reality does something the script would never allow. Look at how this one is shot. Vertical. Handheld. A little shaky. The framing is slightly off. The sun is in the wrong place. The audio picks up whatever happened to be nearby. A professional would have thrown it away. And yet that imperfection is exactly why it works. It tells your brain: this happened. Nobody arranged this. Nobody had time to. In an age when everything online feels manufactured, raw footage of a real moment is the rarest luxury we have. THREE THINGS TO WATCH FOR (WITHOUT ME SPOILING ANYTHING) I promised I would not describe the clip. I am a man of my word. But I will give you three things to watch for, so you do not miss what makes it special. First, watch the distance. Notice how close the animal is willing to get, and then ask yourself how close you would let a wild thing get before your instincts took over. Second, watch the stillness. Not the animal's. The people's. See how little they move, and how much that tiny amount of movement matters. Third, watch the last few seconds. That is where everything changes. That is where the clip stops being a cute animal video and becomes something else entirely, something I have not been able to shake since I first saw it. If you only watch one thing today, make it that. THE QUESTION THAT HAUNTS ME I keep coming back to one question. Why do we need clips like this? We have more access to nature footage than any generation in history. We have documentaries filmed from satellites and cameras that can follow a snow leopard across a Himalayan ridge. We can watch anything, anywhere, in ultra-high definition. And yet a shaky vertical video from a parking lot hits harder than any of it. I think the reason is simple. A documentary shows you nature as something far away. A parking lot shows you nature as something that can touch your life on an ordinary day. We spend most of our lives sealed inside cars, offices, and screens. We have built a world designed to keep the wild out. And every so often, the wild walks up to the door, shrugs, and says: still here. That is why we stop. That is why we watch. That is why we send it to our mothers. It is not really a video about a deer. It is a video about the thin line between the world we built and the world we came from, and the quiet, shocking moment when one steps across it. WHY THIS CLIP WILL OUTLIVE THE WEEK Most viral videos burn out in a day. They spike, they get stolen, they get reposted with a siren emoji, and by Friday nobody can remember what they were about. A few do not. The ones that last share a single trait: they give you a story you can retell in one sentence. A deer walked up to a stranger in a parking lot, and the stranger did everything right. That is it. That is the whole pitch. You will say it out loud to somebody at dinner. They will ask to see it. And the cycle will start again. I have watched that pattern build empires. I have never once seen it fail. THE LAST THING I WILL SAY BEFORE YOU PRESS PLAY If you take nothing else from this post, take this. Wild animals are not props. They are not pets. They are not mascots. They are not content, even when they make great content. They are neighbors with a very different set of rules, and they are doing their best in a world that keeps changing underneath them. The ones that show up in parking lots are not ambassadors. They are survivors, figuring out a landscape that was redrawn without their consent. When one of them meets a human with calm and respect, and nobody gets hurt, that is not a trick of the algorithm. That is a rare, fragile, genuinely good thing. So watch the clip. Watch it once for the animal. Watch it again for the people. Then watch it a third time and ask yourself the question I cannot stop asking: What would I have done? Would you have stayed still? Would you have reached out? Would you have backed away? Would you have grabbed your phone, or would you have forgotten you owned one? Be honest. Most of us would have gotten it wrong. Drop your answer below. I read every reply, and the best ones will be pinned. And if this post made you feel something, even a little, send it to the one person you know who still believes the world has room for quiet miracles. They need to see this. Everyone does. Now press play, and tell me what you saw. P.S. If you have ever stood still in front of a wild animal and felt the whole world go quiet, you already know what I am talking about. Tell me where it happened, what it was, and how long the moment lasted. I collect these stories, and the strangest one gets its own post tomorrow.

Earth Unveiled

26,456 Aufrufe • vor 1 Monat

I still don't understand why everyone is still running agents in a line. I switched to graphs three weeks ago and my fleet finished in the time my single agent used to spend on step two. what slows every agent system I have seen is not intelligence. it is geometry. and almost nobody is talking about it. one engineer used this to rewrite 535,000 lines of code in 11 days. a manual rewrite of that scale could take close to a year. it cost $165,000 in tokens. the graph was not cheap. it was just faster than a human year. a node is one agent with one job. research one competitor. review one file. check one claim. the moment a node owns two independent jobs you lose the ability to parallelize them cleanly, verify them independently, and debug them in isolation. an edge is a dependency. it only exists when data actually moves across it. everything else is a fake edge. a wait you invented that costs time and produces nothing. find the fake edges and the line collapses into something wider. jobs that can run at the same time run at the same time. what used to take the sum of forty steps now finishes in the time of the slowest layer. the pattern behind every serious agent system looks like a diamond. fan out to gather breadth, one agent per angle, all at once. reduce with plain code, no model tokens spent. verify with a fresh skeptic on every finding. synthesize once from what survived. Claude's own research feature uses a very similar pattern in production. the part nobody warns you about: the verifier needs clean context. give it the same conversation the worker had and it is not checking anything. it is nodding along to itself in a different window. a graph of agents sharing one context is a single loop in a costume. it breaks the same way, just later and more expensively. one rule that holds at every scale. a worker and its verifier must never share a context. your agents are not too slow. they are waiting in a line that did not need to exist. full guide in the article. save it before you build your next agent from scratch.

I still don't understand why everyone is still running agents in a line. I switched to graphs three weeks ago and my fleet finished in the time my single agent used to spend on step two. what slows every agent system I have seen is not intelligence. it is geometry. and almost nobody is talking about it. one engineer used this to rewrite 535,000 lines of code in 11 days. a manual rewrite of that scale could take close to a year. it cost $165,000 in tokens. the graph was not cheap. it was just faster than a human year. a node is one agent with one job. research one competitor. review one file. check one claim. the moment a node owns two independent jobs you lose the ability to parallelize them cleanly, verify them independently, and debug them in isolation. an edge is a dependency. it only exists when data actually moves across it. everything else is a fake edge. a wait you invented that costs time and produces nothing. find the fake edges and the line collapses into something wider. jobs that can run at the same time run at the same time. what used to take the sum of forty steps now finishes in the time of the slowest layer. the pattern behind every serious agent system looks like a diamond. fan out to gather breadth, one agent per angle, all at once. reduce with plain code, no model tokens spent. verify with a fresh skeptic on every finding. synthesize once from what survived. Claude's own research feature uses a very similar pattern in production. the part nobody warns you about: the verifier needs clean context. give it the same conversation the worker had and it is not checking anything. it is nodding along to itself in a different window. a graph of agents sharing one context is a single loop in a costume. it breaks the same way, just later and more expensively. one rule that holds at every scale. a worker and its verifier must never share a context. your agents are not too slow. they are waiting in a line that did not need to exist. full guide in the article. save it before you build your next agent from scratch.

rvaniaaa

259,393 Aufrufe • vor 1 Monat