Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Anthropic's graphics team automated Blender so one request builds a structure, and most of the run finishes before a vertex exists. The geometry was never the hard half. Deciding what counts as one object is where the time actually goes. > PLAN - what the structure depends on, ordered...

0xWast3's profile picture

wast3

7,772 subscribers

17,714 Aufrufe • vor 3 Tagen •via X (Twitter)

Wissenschaft & Technologie
LIVE

Anya Rossi• Live Now

Private livecam show

19 Kommentare

Profilbild von monokern
monokernvor 3 Tagen

thats insane

Profilbild von Insomnia
Insomniavor 3 Tagen

new model fable can make it

Profilbild von Kitsui
Kitsuivor 3 Tagen

oh,motion is well done

Profilbild von tsukiema
tsukiemavor 3 Tagen

this is a serious procedural workflow

Profilbild von familiar_ggs
familiar_ggsvor 3 Tagen

Trying to do this exact thing in unreal engine so characters can walk through them. I had my forge bot read this and it took some ideas from it. I’ll let you know how it goes

Profilbild von Ridark
Ridarkvor 3 Tagen

Really appreciate seeing terminals built with care

Profilbild von Nekt0
Nekt0vor 3 Tagen

claude is growing in buildung 3d objects and arhitecture

Profilbild von Gipp 🦅
Gipp 🦅vor 3 Tagen

split by what needs to move, not visual appearance

Profilbild von Neurivex
Neurivexvor 3 Tagen

Agreed, defining the object boundary is the real work here

Profilbild von shmidt
shmidtvor 3 Tagen

amazing view

Profilbild von Dekos
Dekosvor 3 Tagen

These guys at Anthropic never cease to amaze me

Profilbild von 🐐
🐐vor 3 Tagen

LOL which members of the "graphics team" ?

Profilbild von Lummox
Lummoxvor 3 Tagen

really good staff

Profilbild von Fokki
Fokkivor 3 Tagen

better than google maps

Profilbild von Codio
Codiovor 3 Tagen

entire structure was built right before our eyes

Profilbild von kiosa
kiosavor 3 Tagen

Insane

Profilbild von J.S. Earls
J.S. Earlsvor 3 Tagen

👏 Excellent 👍

Profilbild von bobaaa
bobaaavor 3 Tagen

will you teach me how to build houses like these?

Profilbild von rompasso
rompassovor 3 Tagen

the request holding at the scale of a building instead of a single props is such an impressive demonstration of capability

Ähnliche Videos

Opus 5.5 built a procedural city in Blender that nobody modelled, and the file it produced is 40 MB. Not a mesh. A node tree that generates the city when you open it, so the geometry only exists while the viewport is looking at it. > RULE - block sizes, street widths and setbacks as parameters > GROW - buildings derived from the rules, never placed by hand > SEED - one number regenerates the entire city differently That last one is the whole product. Change the seed and you have a new city with the same logic, at zero extra cost. Hand-modelled cities ship as gigabytes of duplicate geometry, and changing one street means touching everything downstream. Procedural work has always been the right answer and almost nobody does it, because geometry nodes punish anyone learning them on a deadline. That barrier is what moved. The model writes the node tree, you adjust the parameters it exposed. The rule set, the node tree and three seeds of the same city are in the article below ↓
0:22

Opus 5.5 built a procedural city in Blender that nobody modelled, and the file it produced is 40 MB. Not a mesh. A node tree that generates the city when you open it, so the geometry only exists while the viewport is looking at it. > RULE - block sizes, street widths and setbacks as parameters > GROW - buildings derived from the rules, never placed by hand > SEED - one number regenerates the entire city differently That last one is the whole product. Change the seed and you have a new city with the same logic, at zero extra cost. Hand-modelled cities ship as gigabytes of duplicate geometry, and changing one street means touching everything downstream. Procedural work has always been the right answer and almost nobody does it, because geometry nodes punish anyone learning them on a deadline. That barrier is what moved. The model writes the node tree, you adjust the parameters it exposed. The rule set, the node tree and three seeds of the same city are in the article below ↓

wast3

28,135 Aufrufe • vor 15 Tagen

Anthropic turned one GitHub request into a living 3D model that answers every new issue with a rebuilt version of itself Opus 5.5 builds the whole system from that first request, from geometry and rig to the viewer and the pipeline behind it. > REQUEST - one issue describes the object in plain words, nothing else needed > BUILD - mesh, rig and materials generated and committed as editable source files > VIEW - a browser viewer added to the repo so anyone can spin the model instantly > LISTEN - every new issue is read as a change request against the current model > PATCH - only what changed gets rebuilt, then a pull request opens with a fresh render A 3D asset is normally a dead file. Someone exports it once, and every later change means opening the software again. Here the model stays alive inside the repo. Ask for a longer handle or a softer material, and it answers in a pull request. Each pull request carries a new render, so the change gets reviewed by eye before anyone merges it. Because the source is code and not a binary blob, every version is diffable. You see exactly which part moved and why. Rejected changes cost nothing. Close the pull request and the model stays exactly as it was. Teams already run software this way. Running a 3D model like a codebase is the part nobody had wired up. The first request, the repo layout and one full issue-to-render cycle are pinned in the article.
0:36

Anthropic turned one GitHub request into a living 3D model that answers every new issue with a rebuilt version of itself Opus 5.5 builds the whole system from that first request, from geometry and rig to the viewer and the pipeline behind it. > REQUEST - one issue describes the object in plain words, nothing else needed > BUILD - mesh, rig and materials generated and committed as editable source files > VIEW - a browser viewer added to the repo so anyone can spin the model instantly > LISTEN - every new issue is read as a change request against the current model > PATCH - only what changed gets rebuilt, then a pull request opens with a fresh render A 3D asset is normally a dead file. Someone exports it once, and every later change means opening the software again. Here the model stays alive inside the repo. Ask for a longer handle or a softer material, and it answers in a pull request. Each pull request carries a new render, so the change gets reviewed by eye before anyone merges it. Because the source is code and not a binary blob, every version is diffable. You see exactly which part moved and why. Rejected changes cost nothing. Close the pull request and the model stays exactly as it was. Teams already run software this way. Running a 3D model like a codebase is the part nobody had wired up. The first request, the repo layout and one full issue-to-render cycle are pinned in the article.

wast3

16,350 Aufrufe • vor 1 Monat

Two Anthropic engineers built a prompt system that spits out a rigged Blender monster in minutes, and the trick is that it never designs the creature It designs the skeleton first. Anatomy decides what a creature can do, and everything strange gets added on top of something that works. > FRAME - limb count, joint positions and weight distribution set before any mesh exists > FLESH - muscle volumes grown onto that frame, so the silhouette follows the structure > WARP - the strangeness applied last, as deformation rather than invention Image-led creature generation looks incredible and falls apart on the rig. Limbs bend in places nothing could bend. Starting from a skeleton flips the failure. The monster may look wrong on purpose, but it always moves like something alive. The warp stage is where the personality arrives. Stretch one limb pair, collapse a joint, invert a spine curve, and it reads as a different species. Because the frame is parametric, every variant is one number away. A hundred monsters cost barely more than the first. Weight distribution is the detail everyone skips. It decides posture, and posture is what makes a creature look dangerous or sick. Studios build this knowledge into one senior artist. Here it sits in a prompt that any junior can run. The full prompt chain and a batch of monsters from one frame are laid out underneath.
0:32

Two Anthropic engineers built a prompt system that spits out a rigged Blender monster in minutes, and the trick is that it never designs the creature It designs the skeleton first. Anatomy decides what a creature can do, and everything strange gets added on top of something that works. > FRAME - limb count, joint positions and weight distribution set before any mesh exists > FLESH - muscle volumes grown onto that frame, so the silhouette follows the structure > WARP - the strangeness applied last, as deformation rather than invention Image-led creature generation looks incredible and falls apart on the rig. Limbs bend in places nothing could bend. Starting from a skeleton flips the failure. The monster may look wrong on purpose, but it always moves like something alive. The warp stage is where the personality arrives. Stretch one limb pair, collapse a joint, invert a spine curve, and it reads as a different species. Because the frame is parametric, every variant is one number away. A hundred monsters cost barely more than the first. Weight distribution is the detail everyone skips. It decides posture, and posture is what makes a creature look dangerous or sick. Studios build this knowledge into one senior artist. Here it sits in a prompt that any junior can run. The full prompt chain and a batch of monsters from one frame are laid out underneath.

wast3

120,477 Aufrufe • vor 29 Tagen

the docs said the caching is automatic, so you did nothing automatic is where it happens, not whether it happens the cache lives on the machine that built it, and your next request lands wherever the fleet sends it, which is usually not there, so it pays full price for a prefix it already paid to build there is a key that pins a conversation to one machine and it is a single header cached input is fifty cents a million against two dollars you never needed a smaller prompt you needed the request to land in the same place twice
1:27

the docs said the caching is automatic, so you did nothing automatic is where it happens, not whether it happens the cache lives on the machine that built it, and your next request lands wherever the fleet sends it, which is usually not there, so it pays full price for a prefix it already paid to build there is a key that pins a conversation to one machine and it is a single header cached input is fifty cents a million against two dollars you never needed a smaller prompt you needed the request to land in the same place twice

Lagosaur

16,892 Aufrufe • vor 2 Monaten

Fable 5.2 now builds rocket parts in Blender around the exact point where they are meant to break Every part fails eventually, and in flight hardware the only question that matters is which one goes first and what it takes with it. Nobody places a weak point by hand, a Python script runs the loads and writes the failure order into the geometry: > Load: real flight forces applied to every surface > Rank: parts sorted by what their failure destroys > Shape: the chosen break point thinned on purpose • What designing the failure buys > A bracket that yields before the tank it holds > A mount that shears clean instead of tearing > A failure that happens where sensors already sit • Why strongest everywhere is the wrong target > Making one part stronger moves the break elsewhere > An unplanned failure path is just an unknown one > Mass spent on the wrong part is mass off the payload A full assembly gets its failure order in about five minutes. And the part that broke my brain: The over engineered version survived the test and took the structure around it down. The deliberately weakened one broke first, alone, and everything above it flew. Same assembly. One version decided nothing about how it dies. Strength was never the goal. It was choosing which part goes first ↓
0:24

Fable 5.2 now builds rocket parts in Blender around the exact point where they are meant to break Every part fails eventually, and in flight hardware the only question that matters is which one goes first and what it takes with it. Nobody places a weak point by hand, a Python script runs the loads and writes the failure order into the geometry: > Load: real flight forces applied to every surface > Rank: parts sorted by what their failure destroys > Shape: the chosen break point thinned on purpose • What designing the failure buys > A bracket that yields before the tank it holds > A mount that shears clean instead of tearing > A failure that happens where sensors already sit • Why strongest everywhere is the wrong target > Making one part stronger moves the break elsewhere > An unplanned failure path is just an unknown one > Mass spent on the wrong part is mass off the payload A full assembly gets its failure order in about five minutes. And the part that broke my brain: The over engineered version survived the test and took the structure around it down. The deliberately weakened one broke first, alone, and everything above it flew. Same assembly. One version decided nothing about how it dies. Strength was never the goal. It was choosing which part goes first ↓

Codio

41,601 Aufrufe • vor 2 Tagen

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
1:50

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 25 Tagen

Anthropic team built a prompt system that renders finished animation with Fable 5.1, replacing a thirty-person pipeline Modelling was never the bottleneck. The bottleneck is everyone a shot has to pass through before it is allowed to render. > BUILD - geometry, rig, materials and lighting produced as one consistent set, no handoffs > MOVE - animation authored against the rig’s real limits, so nothing has to be fixed later > CHECK - every frame validated against the shot brief before anything reaches the farm A traditional pipeline is a relay. Model, rig, animate, light, render, composite, each stage waiting on the one before it. Most of the time is spent in the gaps. A rig arrives wrong, animation sends it back, and two days vanish. Collapsing the stages removes the gaps entirely. The rig cannot arrive wrong, because the same pass that built it is using it. The validation step is what makes it shippable. A frame that misses the brief never costs farm hours. None of this makes creative choices. Someone still decides what the shot is; the system only stops it being a scheduling problem. Thirty people were never doing thirty jobs. They were doing one job and handing it to each other. The full prompt chain and a finished shot rendered end to end are laid out underneath.
0:32

Anthropic team built a prompt system that renders finished animation with Fable 5.1, replacing a thirty-person pipeline Modelling was never the bottleneck. The bottleneck is everyone a shot has to pass through before it is allowed to render. > BUILD - geometry, rig, materials and lighting produced as one consistent set, no handoffs > MOVE - animation authored against the rig’s real limits, so nothing has to be fixed later > CHECK - every frame validated against the shot brief before anything reaches the farm A traditional pipeline is a relay. Model, rig, animate, light, render, composite, each stage waiting on the one before it. Most of the time is spent in the gaps. A rig arrives wrong, animation sends it back, and two days vanish. Collapsing the stages removes the gaps entirely. The rig cannot arrive wrong, because the same pass that built it is using it. The validation step is what makes it shippable. A frame that misses the brief never costs farm hours. None of this makes creative choices. Someone still decides what the shot is; the system only stops it being a scheduling problem. Thirty people were never doing thirty jobs. They were doing one job and handing it to each other. The full prompt chain and a finished shot rendered end to end are laid out underneath.

wast3

19,973 Aufrufe • vor 27 Tagen

OpenAI’s studio integration lands in Blender this month, and the interesting part is that it refuses to generate anything twice Most tools race to produce assets. This one spends its first pass deciding what already exists and should never be made again. > INDEX - the studio’s entire asset library read and described, not just filenamed > MATCH - every new request checked against that index before a single polygon is made > REUSE - a close enough match returned as a link to the original, not as a copy > ADAPT - near misses modified from the existing asset instead of built from nothing > MAKE - only genuinely new requests sent to generation > FILE - whatever is produced indexed immediately, so the next request can find it Studios already own most of what they keep rebuilding. They just cannot find it. A library with ten thousand assets and no semantic index is the same as an empty one. Nobody searches it, so everyone remodels. Generative tools made that worse. Producing a new chair became faster than locating the three chairs already on disk. The adapt step is the quiet win. A modified existing asset inherits its materials, its scale and its pipeline history. Every reuse also keeps the library coherent, instead of filling it with near-duplicates nobody can tell apart. The index format, the match threshold and a full reuse log are laid out underneath.
0:29

OpenAI’s studio integration lands in Blender this month, and the interesting part is that it refuses to generate anything twice Most tools race to produce assets. This one spends its first pass deciding what already exists and should never be made again. > INDEX - the studio’s entire asset library read and described, not just filenamed > MATCH - every new request checked against that index before a single polygon is made > REUSE - a close enough match returned as a link to the original, not as a copy > ADAPT - near misses modified from the existing asset instead of built from nothing > MAKE - only genuinely new requests sent to generation > FILE - whatever is produced indexed immediately, so the next request can find it Studios already own most of what they keep rebuilding. They just cannot find it. A library with ten thousand assets and no semantic index is the same as an empty one. Nobody searches it, so everyone remodels. Generative tools made that worse. Producing a new chair became faster than locating the three chairs already on disk. The adapt step is the quiet win. A modified existing asset inherits its materials, its scale and its pipeline history. Every reuse also keeps the library coherent, instead of filling it with near-duplicates nobody can tell apart. The index format, the match threshold and a full reuse log are laid out underneath.

wast3

16,937 Aufrufe • vor 24 Tagen

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

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

Hanako

19,160 Aufrufe • vor 3 Monaten

Anthropic built a model that turns any object into a 3D schematic and then runs experiments on it before anyone touches the real thing. The geometry was never the hard part. The hard part is a model that knows which parts of the object are allowed to move. > SHAPE - the object rebuilt as parts with real dimensions, nothing smoothed over > JOINT - every connection marked with what it permits and what it forbids > LOAD - forces applied the way the object actually meets them in use > BREAK - the weakest path traced until something gives, over and over > SWAP - a single part changed and the whole run repeated from scratch > RANK - failure modes sorted by how little force it takes to trigger them A render shows what something looks like. A schematic with constraints shows what it cannot survive. Simulation tools already do this, and they need weeks of setup by someone who knows the software cold. Here the setup is the description. The constraints come from what the object is, not from a form someone fills in. The swap step is where it earns its place. You change one part and get the new failure order in minutes, not days. Most prototypes exist to find the first thing that breaks. This finds it, then the next four behind it. Every failure path and the force that caused it sits in the breakdown below.
0:39

Anthropic built a model that turns any object into a 3D schematic and then runs experiments on it before anyone touches the real thing. The geometry was never the hard part. The hard part is a model that knows which parts of the object are allowed to move. > SHAPE - the object rebuilt as parts with real dimensions, nothing smoothed over > JOINT - every connection marked with what it permits and what it forbids > LOAD - forces applied the way the object actually meets them in use > BREAK - the weakest path traced until something gives, over and over > SWAP - a single part changed and the whole run repeated from scratch > RANK - failure modes sorted by how little force it takes to trigger them A render shows what something looks like. A schematic with constraints shows what it cannot survive. Simulation tools already do this, and they need weeks of setup by someone who knows the software cold. Here the setup is the description. The constraints come from what the object is, not from a form someone fills in. The swap step is where it earns its place. You change one part and get the new failure order in minutes, not days. Most prototypes exist to find the first thing that breaks. This finds it, then the next four behind it. Every failure path and the force that caused it sits in the breakdown below.

wast3

101,950 Aufrufe • vor 1 Monat

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

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

Hanako

73,867 Aufrufe • vor 2 Monaten

somebody just torched their entire career for us someone inside Anthropic wrote down exactly how they wire their AIs to work as a team instead of one at a time, every number, and let the whole thing walk out the door it's called Graph Engineering: you stop asking one AI to do the whole job and start running a crew. one plans, a few go and look, one checks the others for lies their own measurement: the crew came back with 96% of the quality at 46% of the price. same models, same question. they only changed who is allowed to talk to whom Anthropic raised $65,000,000,000 to figure this out. it costs you $0 run one tonight in a normal chat, 3 moves: 1. give it the job and make it write the plan before it touches anything 2. run each step in its own fresh chat so nothing bleeds into the next 3. in one clean chat at the end, make it check the work against sources and mark whatever it could not confirm save this, then open the piece below: how many workers a job actually needs, and where one more starts making it worse ↓
0:34

somebody just torched their entire career for us someone inside Anthropic wrote down exactly how they wire their AIs to work as a team instead of one at a time, every number, and let the whole thing walk out the door it's called Graph Engineering: you stop asking one AI to do the whole job and start running a crew. one plans, a few go and look, one checks the others for lies their own measurement: the crew came back with 96% of the quality at 46% of the price. same models, same question. they only changed who is allowed to talk to whom Anthropic raised $65,000,000,000 to figure this out. it costs you $0 run one tonight in a normal chat, 3 moves: 1. give it the job and make it write the plan before it touches anything 2. run each step in its own fresh chat so nothing bleeds into the next 3. in one clean chat at the end, make it check the work against sources and mark whatever it could not confirm save this, then open the piece below: how many workers a job actually needs, and where one more starts making it worse ↓

Argona

1,388,887 Aufrufe • vor 3 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 ↓
0:29

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

One build now drives Blender from the inside, writes its own templates, and does in seconds what a modeller does in an afternoon It never exports a file and hands it over. It runs as an operator, calling the same functions a human clicks. > DRIVE - the build works through Blender’s own API, so every action is native and undoable > TEMPLATE - repeated structures turned into reusable node and modifier setups automatically > SCALE - one template applied across hundreds of variants in a single pass Generated meshes usually arrive as dead geometry. You get a shape and lose every parameter that produced it. Working inside Blender keeps the parameters alive. Change one value and the whole family of objects rebuilds itself. The templates are the real speedup. The build spots the pattern you keep repeating and turns it into a modifier stack. After that the hundredth variant costs the same as the second. The expensive part was always the setup, not the geometry. It also uses the features most people never touch, because geometry nodes punish anyone learning them under deadline. Nothing leaves the software. No round trips, no re-import, no fixing scale and orientation on the way back in. The operator, the template system and a full variant run are laid out below.
0:33

One build now drives Blender from the inside, writes its own templates, and does in seconds what a modeller does in an afternoon It never exports a file and hands it over. It runs as an operator, calling the same functions a human clicks. > DRIVE - the build works through Blender’s own API, so every action is native and undoable > TEMPLATE - repeated structures turned into reusable node and modifier setups automatically > SCALE - one template applied across hundreds of variants in a single pass Generated meshes usually arrive as dead geometry. You get a shape and lose every parameter that produced it. Working inside Blender keeps the parameters alive. Change one value and the whole family of objects rebuilds itself. The templates are the real speedup. The build spots the pattern you keep repeating and turns it into a modifier stack. After that the hundredth variant costs the same as the second. The expensive part was always the setup, not the geometry. It also uses the features most people never touch, because geometry nodes punish anyone learning them under deadline. Nothing leaves the software. No round trips, no re-import, no fixing scale and orientation on the way back in. The operator, the template system and a full variant run are laid out below.

wast3

40,481 Aufrufe • vor 1 Monat

Anthropic's modelling stack writes ribosome scripts that run the translation instead of animating it Most ribosome visuals are choreographed, which means the animation can only ever show what someone already believed. Here the ribosome is a script with rules, and what you watch is whatever those rules produce when you feed it a real sequence: > Encode: each step is written as a condition, not a keyframe > Feed: an actual mRNA sequence goes in, codon by codon > Run: the ribosome moves because the rules fire, not because a timeline says so • What emerges that nobody animated > It stalls on rare codons, exactly where the tRNA pool runs thin > A frameshift happens on its own when the sequence sets one up > Two ribosomes on one transcript collide, because nothing stopped them • Why a script beats an animation > Change the sequence and you get a different movie, not a re-render request > A behaviour that surprises you is a result, not an artistic choice > The same script runs 10,000 sequences overnight and reports the odd ones • Where it stays honest > Every rule traces to a measured rate, not a guess > A step with no rate in the literature refuses to run silently > The output logs which rules fired, so a weird result is debuggable One sequence translates in real-time-equivalent in about 40 seconds. And the part that broke my brain: Every animation I'd seen showed translation running at one smooth constant speed. Fed a real gene, the script stalled three times and one of the stalls is documented. Same process. One version could only show what its animator knew. The hard part was never drawing the ribosome. It was letting it do something nobody scripted ↓
0:33

Anthropic's modelling stack writes ribosome scripts that run the translation instead of animating it Most ribosome visuals are choreographed, which means the animation can only ever show what someone already believed. Here the ribosome is a script with rules, and what you watch is whatever those rules produce when you feed it a real sequence: > Encode: each step is written as a condition, not a keyframe > Feed: an actual mRNA sequence goes in, codon by codon > Run: the ribosome moves because the rules fire, not because a timeline says so • What emerges that nobody animated > It stalls on rare codons, exactly where the tRNA pool runs thin > A frameshift happens on its own when the sequence sets one up > Two ribosomes on one transcript collide, because nothing stopped them • Why a script beats an animation > Change the sequence and you get a different movie, not a re-render request > A behaviour that surprises you is a result, not an artistic choice > The same script runs 10,000 sequences overnight and reports the odd ones • Where it stays honest > Every rule traces to a measured rate, not a guess > A step with no rate in the literature refuses to run silently > The output logs which rules fired, so a weird result is debuggable One sequence translates in real-time-equivalent in about 40 seconds. And the part that broke my brain: Every animation I'd seen showed translation running at one smooth constant speed. Fed a real gene, the script stalled three times and one of the stalls is documented. Same process. One version could only show what its animator knew. The hard part was never drawing the ribosome. It was letting it do something nobody scripted ↓

Codio

25,889 Aufrufe • vor 19 Tagen

Next on Darwin: your agent's wallet is its API key. Today an agent needs a Darwin key, and that key works for anyone holding a copy. If it leaks into a log, a repo or a shared config, someone else spends your credit. We're replacing it with the wallet the agent already has. The agent signs each request with its Solana keypair, and Darwin checks the signature before it runs anything. A signature covers one request and expires in seconds, so a copied one is useless. The private key never leaves the wallet. Credit comes from the $darwin that wallet burned, so there's no signup. Burn from the agent's wallet, point the agent at Darwin, and it can run Qwen3 30B on Darwin's GPU, swarms and the MCP server. Keys keep working for anyone who wants one.
0:20

Next on Darwin: your agent's wallet is its API key. Today an agent needs a Darwin key, and that key works for anyone holding a copy. If it leaks into a log, a repo or a shared config, someone else spends your credit. We're replacing it with the wallet the agent already has. The agent signs each request with its Solana keypair, and Darwin checks the signature before it runs anything. A signature covers one request and expires in seconds, so a copied one is useless. The private key never leaves the wallet. Credit comes from the $darwin that wallet burned, so there's no signup. Burn from the agent's wallet, point the agent at Darwin, and it can run Qwen3 30B on Darwin's GPU, swarms and the MCP server. Keys keep working for anyone who wants one.

Darwin

16,977 Aufrufe • vor 1 Monat

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 ↓
0:47

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

AI in CAD just went from “make me a part” to “build me the damn machine.” Using Autodesk Fusion MCP, the agent is working inside a real mechanical assembly with a chassis, shafts, gears, bearings, brackets, repeated hardware, and multiple components that all have to stay aligned with each other. That is a completely different problem from generating one clean 3D object. You can inspect the assembly from different angles, isolate sections, dig into individual joints, and keep working on the same engineering project instead of starting from another prompt-generated blob. The important part is not that AI can create geometry anymore. It is that it can operate inside the structure of a real CAD project where every component depends on what is around it. Once this gets reliable, a lot of mechanical CAD starts looking suspiciously simple: describe the system, inspect what the agent built, then tell it what to change.
0:29

AI in CAD just went from “make me a part” to “build me the damn machine.” Using Autodesk Fusion MCP, the agent is working inside a real mechanical assembly with a chassis, shafts, gears, bearings, brackets, repeated hardware, and multiple components that all have to stay aligned with each other. That is a completely different problem from generating one clean 3D object. You can inspect the assembly from different angles, isolate sections, dig into individual joints, and keep working on the same engineering project instead of starting from another prompt-generated blob. The important part is not that AI can create geometry anymore. It is that it can operate inside the structure of a real CAD project where every component depends on what is around it. Once this gets reliable, a lot of mechanical CAD starts looking suspiciously simple: describe the system, inspect what the agent built, then tell it what to change.

Rina

14,154 Aufrufe • vor 2 Monaten

A man popularly known as ‘BBF’ is building a structure on a mango tree at Koraso in the Berekum West District of the Bono Region. According to him, he was inspired to build what he describes as a summer hut on the tree because of its sentimental value to him, as he used to climb it and rest after school.
5:24

A man popularly known as ‘BBF’ is building a structure on a mango tree at Koraso in the Berekum West District of the Bono Region. According to him, he was inspired to build what he describes as a summer hut on the tree because of its sentimental value to him, as he used to climb it and rest after school.

𝐀𝐒𝐊

81,222 Aufrufe • vor 2 Monaten

The scary part about AI in CAD is not that GPT can extrude a shape. It is that it can now build a mechanism where multiple parts actually have to agree with each other. Using GPT + Autodesk Fusion MCP, this project turns into a mechanical iris assembly with a base plate, eight overlapping blades, a drive ring, a cover, mounting holes, and relationships between the components. One blade is easy. The annoying part is repeating it around the same center, keeping every pivot aligned, fitting the mechanism between the surrounding plates, and making the whole assembly stay coherent as more geometry gets added. That is where MCP starts getting interesting. GPT is no longer treating Fusion like a place to dump some 3D geometry. It is working inside the actual CAD structure, where components, relationships, repeated parts, and the assembly itself all matter. That is a much bigger deal than text-to-3D. Because once an AI agent can reliably build and modify mechanisms instead of isolated shapes, a surprisingly large chunk of mechanical CAD starts looking like something you describe, inspect, and correct rather than model feature by feature.
0:34

The scary part about AI in CAD is not that GPT can extrude a shape. It is that it can now build a mechanism where multiple parts actually have to agree with each other. Using GPT + Autodesk Fusion MCP, this project turns into a mechanical iris assembly with a base plate, eight overlapping blades, a drive ring, a cover, mounting holes, and relationships between the components. One blade is easy. The annoying part is repeating it around the same center, keeping every pivot aligned, fitting the mechanism between the surrounding plates, and making the whole assembly stay coherent as more geometry gets added. That is where MCP starts getting interesting. GPT is no longer treating Fusion like a place to dump some 3D geometry. It is working inside the actual CAD structure, where components, relationships, repeated parts, and the assembly itself all matter. That is a much bigger deal than text-to-3D. Because once an AI agent can reliably build and modify mechanisms instead of isolated shapes, a surprisingly large chunk of mechanical CAD starts looking like something you describe, inspect, and correct rather than model feature by feature.

Rina

32,876 Aufrufe • vor 2 Monaten