Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

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...

0xWast3's profile picture

wast3

7,217 subscribers

16,350 Aufrufe • vor 23 Tagen •via X (Twitter)

Wissenschaft & Technologie
LIVE

Anya Rossi• Live Now

Private livecam show

18 Kommentare

Profilbild von Dekos
Dekosvor 23 Tagen

I wonder when the development of SHIT will stop.

Profilbild von Insomnia
Insomniavor 23 Tagen

bro I love to see it now

Profilbild von Danylo Fedorenko
Danylo Fedorenkovor 23 Tagen

this is such a cool idea. does it rebuild from scratch every time or just patch the old one?

Profilbild von 0xbobaa
0xbobaavor 23 Tagen

What kind of repository is this?

Profilbild von Zero
Zerovor 23 Tagen

damn, that’s insanely detailed!

Profilbild von shmidt
shmidtvor 23 Tagen

cool dot

Profilbild von beamnxw ./
beamnxw ./vor 23 Tagen

insane

Profilbild von Celebs Hub
Celebs Hubvor 23 Tagen

The idea that a 3D asset is dead until reopened in software is doing a lot of heavy lifting here; git already did this for code, you just pointed it at a mesh.

Profilbild von kemal buger
kemal bugervor 23 Tagen

Evren resmen davetiye göndermiş, FungoLabs daha neyi bekliyor?

Profilbild von magsimich
magsimichvor 23 Tagen

Wow this looks good to me

Profilbild von Biscuit
Biscuitvor 23 Tagen

client revisions would be so much easier

Profilbild von monokern
monokernvor 23 Tagen

new render in every pr is smart

Profilbild von Ridark
Ridarkvor 23 Tagen

You have a unique terminal with a really interesting approach for real for sure honestly for real, how did you build it out?

Profilbild von Antony Claude
Antony Claudevor 23 Tagen

this is pretty cool and very useful for 3d devs

Profilbild von kiosa
kiosavor 23 Tagen

Cool Fam

Profilbild von Lummox
Lummoxvor 23 Tagen

It’s really pretty

Profilbild von Gipp 🦅
Gipp 🦅vor 23 Tagen

plain text requests in opus 5.5 always flag my mesh changes cleaner than my old modeling workflow

Profilbild von Codio
Codiovor 23 Tagen

share that github repo with me via dm

Ähnliche Videos

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

Fusion Models by robinhood:0xa92768863a55d8a0591709f7f5e594a249d36ea3, explained properly. Why a panel beats one model: Ask three models the same hard question and they disagree. The disagreement is the information, where they contradict each other is where one of them is wrong, and a judge can see it. OpenRouter shipped exactly this in June and their panels beat any single frontier model. Credit to them and their $10B sale to stripe. Why the same panel for everyone is the wrong shape: You don't have one best model. You have a best model per job. The one you trust for code is not the one you trust for writing, and neither is the one you'd pick for a five-line reply. A panel chosen per request, identical for every user, can't know that. A panel arranged around you can. The number that matters isn't price: It's cost per answer that works. Model A costs $4 per million tokens and gets your job right one time in four. Model B costs $10 and gets it right three times in four. Per answer you actually keep, A costs $16 and B costs $13. The cheap model was the expensive one. Everyone comparing price lists is measuring the wrong thing. You never rate anything: Stopping an answer halfway is a rating. Regenerating is a rating. Switching model and asking again is the loudest rating there is. Every one of those already writes a row we can learn from. The router learns which models earn your credits, per job, and tries a cheaper one now and then to check. Fusion only when it pays: Cost mode tries the cheap model first and escalates only if a judge says it failed. Performance mode fans out to your panel and merges. Most simple prompts never fuse. That's why it costs less, not more. Put it together and you have a personal model: Not trained. Assembled. Your profile from a two-minute questionnaire and everything you've imported from Claude or ChatGPT. Your memory, shared across every model so switching never starts from zero. Your skills, workflows you build once and run on any model. Your scorecard, which models earn your credits per job. One per person. Nobody else has yours. Every model is someone else's; the arrangement is you, and it leaves with you. People aren't loyal to models. They're loyal to results. A moat can't be a commodity, but it can be our own creation.
0:46

Fusion Models by robinhood:0xa92768863a55d8a0591709f7f5e594a249d36ea3, explained properly. Why a panel beats one model: Ask three models the same hard question and they disagree. The disagreement is the information, where they contradict each other is where one of them is wrong, and a judge can see it. OpenRouter shipped exactly this in June and their panels beat any single frontier model. Credit to them and their $10B sale to stripe. Why the same panel for everyone is the wrong shape: You don't have one best model. You have a best model per job. The one you trust for code is not the one you trust for writing, and neither is the one you'd pick for a five-line reply. A panel chosen per request, identical for every user, can't know that. A panel arranged around you can. The number that matters isn't price: It's cost per answer that works. Model A costs $4 per million tokens and gets your job right one time in four. Model B costs $10 and gets it right three times in four. Per answer you actually keep, A costs $16 and B costs $13. The cheap model was the expensive one. Everyone comparing price lists is measuring the wrong thing. You never rate anything: Stopping an answer halfway is a rating. Regenerating is a rating. Switching model and asking again is the loudest rating there is. Every one of those already writes a row we can learn from. The router learns which models earn your credits, per job, and tries a cheaper one now and then to check. Fusion only when it pays: Cost mode tries the cheap model first and escalates only if a judge says it failed. Performance mode fans out to your panel and merges. Most simple prompts never fuse. That's why it costs less, not more. Put it together and you have a personal model: Not trained. Assembled. Your profile from a two-minute questionnaire and everything you've imported from Claude or ChatGPT. Your memory, shared across every model so switching never starts from zero. Your skills, workflows you build once and run on any model. Your scorecard, which models earn your credits per job. One per person. Nobody else has yours. Every model is someone else's; the arrangement is you, and it leaves with you. People aren't loyal to models. They're loyal to results. A moat can't be a commodity, but it can be our own creation.

askr

13,917 Aufrufe • vor 1 Monat

Production traffic is not uniform. You get a few requests that need your best model, but most are simple questions and lookups you can solve with cheaper, faster models. The most expensive mistake you can make today is sending every request to your strongest model. You need routing. Period. This is the simplest trick to improve the architecture of whatever you are building. Please, don't implement routing yourself. You don't have to. I'm currently working with TrueFoundry's Auto Routing. It reads each request, classifies it as simple, medium, or complex, and sends it to the model assigned to that tier. You have two choices: 1. Send every request to the free heuristic classifier to score signals such as technical vocabulary, code, prompt length, and multi-step reasoning. 2. Send the request to an LLM classifier when its difficulty requires a more nuanced judgment. The beauty of using routing is that nothing changes in your code. You still call a single endpoint model, but routing works behind the scenes to pair every request with the best possible model. TrueFoundry ran several experiments with two different setups: 1. Send every request to Claude Opus 2. Send every request to a router with Haiku, Sonnet, and Opus The first experiment ran 550 deterministically graded academic prompts through every setup. Auto Routing was 69% cheaper while retaining 98% of the baseline quality. The second experiment ran three production-shaped workloads through every setup, using user chats, developer chats, and long agent tasks. Auto Routing was 80% cheaper. Thanks to the TrueFoundry team for partnering with me on this post.
1:28

Production traffic is not uniform. You get a few requests that need your best model, but most are simple questions and lookups you can solve with cheaper, faster models. The most expensive mistake you can make today is sending every request to your strongest model. You need routing. Period. This is the simplest trick to improve the architecture of whatever you are building. Please, don't implement routing yourself. You don't have to. I'm currently working with TrueFoundry's Auto Routing. It reads each request, classifies it as simple, medium, or complex, and sends it to the model assigned to that tier. You have two choices: 1. Send every request to the free heuristic classifier to score signals such as technical vocabulary, code, prompt length, and multi-step reasoning. 2. Send the request to an LLM classifier when its difficulty requires a more nuanced judgment. The beauty of using routing is that nothing changes in your code. You still call a single endpoint model, but routing works behind the scenes to pair every request with the best possible model. TrueFoundry ran several experiments with two different setups: 1. Send every request to Claude Opus 2. Send every request to a router with Haiku, Sonnet, and Opus The first experiment ran 550 deterministically graded academic prompts through every setup. Auto Routing was 69% cheaper while retaining 98% of the baseline quality. The second experiment ran three production-shaped workloads through every setup, using user chats, developer chats, and long agent tasks. Auto Routing was 80% cheaper. Thanks to the TrueFoundry team for partnering with me on this post.

Santiago

15,543 Aufrufe • vor 1 Monat

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

we just shipped Magic Sessions in Trylle a new way to run longer coding tasks directly from your repos try it on - start from an issue - kick off a task - test the change - open the PR here’s me taking a real issue all the way to a pull request
1:55

we just shipped Magic Sessions in Trylle a new way to run longer coding tasks directly from your repos try it on - start from an issue - kick off a task - test the change - open the PR here’s me taking a real issue all the way to a pull request

alan

53,128 Aufrufe • vor 1 Monat

Do you understand what just got open sourced? 5,800+ quant trading strategies for FREE along with its CODEBASE i gave these trading strategies to opus 5.5 + jev and it built me a PROFITABLE 24/7 trading agent here is how to use the repo and build AI trading bot: 1. clone the vault and get 5,806 trading strategies (spot, perps, grid, stat arb and market making) 2. open any strategy file, the math, the parameters and the source are already inside 3. point AgenKit at that file inside Claude Code with model as opus 5.5, one command and it reads the spec as ground truth 4. it will run a full engineering team and ships a production bot with risk controls 5. Jev is the live brain, it answers buy sell or hold in 81 milliseconds, calibrated, no hallucination 6. your engine sizes the trade from that confidence and fires it before the next block 7. a hard risk layer holds every limit, nothing goes live until you approve it 8. every night Opus 5.5 reviews the fills and ships a better version, so the agent improves while you sleep one model THINKS, the other REACTS and a strategy that sat locked in a vault now trades itself 24/7 the COMPLETE codebase and the EXACT Opus 5.5 + Jev trading system which I am running is in the article below:
0:39

Do you understand what just got open sourced? 5,800+ quant trading strategies for FREE along with its CODEBASE i gave these trading strategies to opus 5.5 + jev and it built me a PROFITABLE 24/7 trading agent here is how to use the repo and build AI trading bot: 1. clone the vault and get 5,806 trading strategies (spot, perps, grid, stat arb and market making) 2. open any strategy file, the math, the parameters and the source are already inside 3. point AgenKit at that file inside Claude Code with model as opus 5.5, one command and it reads the spec as ground truth 4. it will run a full engineering team and ships a production bot with risk controls 5. Jev is the live brain, it answers buy sell or hold in 81 milliseconds, calibrated, no hallucination 6. your engine sizes the trade from that confidence and fires it before the next block 7. a hard risk layer holds every limit, nothing goes live until you approve it 8. every night Opus 5.5 reviews the fills and ships a better version, so the agent improves while you sleep one model THINKS, the other REACTS and a strategy that sat locked in a vault now trades itself 24/7 the COMPLETE codebase and the EXACT Opus 5.5 + Jev trading system which I am running is in the article below:

Roan

96,820 Aufrufe • vor 1 Monat

We've reached a small but exciting milestone for OpenDevin, the open source AI software engineer -- OpenDevin sends a pull request to the OpenDevin repo. You can see the PR here:
2:16

We've reached a small but exciting milestone for OpenDevin, the open source AI software engineer -- OpenDevin sends a pull request to the OpenDevin repo. You can see the PR here:

Graham Neubig

53,069 Aufrufe • vor 2 Jahren

THIS GUY REBUILT A CHILDHOOD PS2 GAME AS A FREE BROWSER VERSION WITH CLAUDE CODE he grew up obsessed with downhill domination, the ps2 downhill mountain biking game that never got a sequel so he rebuilt the entire thing from scratch > its a full downhill biking game you play right in your browser, nothing to install > the whole thing is one single html file with no separate image, model, or sound files > everything, the track, the bike, the physics, is generated in code, not loaded from assets > built with fable, opus, vanilla js and three.js over multiple sessions of iterating someone even sent a pull request to add controller support, he merged it, and people helped him squash bugs on the fly a dead ps2 game came back to life as an open source community project this is the best use of this stuff
0:21

THIS GUY REBUILT A CHILDHOOD PS2 GAME AS A FREE BROWSER VERSION WITH CLAUDE CODE he grew up obsessed with downhill domination, the ps2 downhill mountain biking game that never got a sequel so he rebuilt the entire thing from scratch > its a full downhill biking game you play right in your browser, nothing to install > the whole thing is one single html file with no separate image, model, or sound files > everything, the track, the bike, the physics, is generated in code, not loaded from assets > built with fable, opus, vanilla js and three.js over multiple sessions of iterating someone even sent a pull request to add controller support, he merged it, and people helped him squash bugs on the fly a dead ps2 game came back to life as an open source community project this is the best use of this stuff

Om Patel

22,230 Aufrufe • vor 3 Monaten

⚡️NEW A Colonel in the Iranian Army made a Request to the Supreme Leader: "‘I request that the Supreme Leader provide me with a Speedboat loaded with Bombs and a Suicide Vest so that I can ram it into an American warship and Blow It up"
0:36

⚡️NEW A Colonel in the Iranian Army made a Request to the Supreme Leader: "‘I request that the Supreme Leader provide me with a Speedboat loaded with Bombs and a Suicide Vest so that I can ram it into an American warship and Blow It up"

Iran Observer

468,968 Aufrufe • vor 1 Monat

📍🇮🇷 NEW: A Colonel in the Iranian Army made a Request to the Supreme Leader: "‘I request that the Supreme Leader provide me with a Speedboat loaded with Bombs and a Suicide Vest so that I can ram it into an American warship and Blow It up"
0:36

📍🇮🇷 NEW: A Colonel in the Iranian Army made a Request to the Supreme Leader: "‘I request that the Supreme Leader provide me with a Speedboat loaded with Bombs and a Suicide Vest so that I can ram it into an American warship and Blow It up"

Jackson Hinkle 🇺🇸

127,896 Aufrufe • vor 1 Monat

Yesterday, Van Jones called me a “demagogue” for discussing the Great Replacement Theory. Well, here are Van’s words in 2021: “The request from the racial justice left: we want the white majority to go from being a majority to being a minority and like it. That’s a tough request, and change is hard.”
0:40

Yesterday, Van Jones called me a “demagogue” for discussing the Great Replacement Theory. Well, here are Van’s words in 2021: “The request from the racial justice left: we want the white majority to go from being a majority to being a minority and like it. That’s a tough request, and change is hard.”

Vivek Ramaswamy

3,605,934 Aufrufe • vor 2 Jahren

A university lab had an LLM build 3D molecules and only kept the ones the model itself couldn't explain Most generative chemistry rewards confidence, which means the output is a very expensive average of the training set. They inverted the filter, the model builds the structure and then has to justify why it works, and the ones it can't justify are the only ones that go forward: > Generate: structures are built against the target property as usual > Explain: the model writes the mechanism it believes makes each one work > Score: a confident, familiar explanation sends the candidate to the discard pile > Keep: anything it builds but cannot account for goes to the bench • Why the unexplainable ones are the valuable ones > A structure the model can explain is one the literature already implies > Novelty lives exactly where the learned pattern stops predicting > The explanation is a proxy for how crowded that chemical space already is • What came out of the first run > Four scaffolds with no close analog in any published series > One binding mode the model described as unlikely and the assay confirmed > A discard pile full of compounds three other groups were already patenting • Where this breaks if you're careless > Unexplainable also describes garbage, so synthesis screening runs first > Every keeper has to survive the same physical validity checks > A candidate with no route to the bench is dropped regardless of novelty One generate-and-filter cycle produces about 30 keepers from 400,000 builds. And the part that broke my brain: Every other pipeline ranks candidates by how sure the model is about them. This lab reads that same confidence as proof somebody already got there. Same model. One version optimises for the middle of what's known. The hard part was never generating molecules. It was noticing that the confident ones are the crowded ones ↓
0:33

A university lab had an LLM build 3D molecules and only kept the ones the model itself couldn't explain Most generative chemistry rewards confidence, which means the output is a very expensive average of the training set. They inverted the filter, the model builds the structure and then has to justify why it works, and the ones it can't justify are the only ones that go forward: > Generate: structures are built against the target property as usual > Explain: the model writes the mechanism it believes makes each one work > Score: a confident, familiar explanation sends the candidate to the discard pile > Keep: anything it builds but cannot account for goes to the bench • Why the unexplainable ones are the valuable ones > A structure the model can explain is one the literature already implies > Novelty lives exactly where the learned pattern stops predicting > The explanation is a proxy for how crowded that chemical space already is • What came out of the first run > Four scaffolds with no close analog in any published series > One binding mode the model described as unlikely and the assay confirmed > A discard pile full of compounds three other groups were already patenting • Where this breaks if you're careless > Unexplainable also describes garbage, so synthesis screening runs first > Every keeper has to survive the same physical validity checks > A candidate with no route to the bench is dropped regardless of novelty One generate-and-filter cycle produces about 30 keepers from 400,000 builds. And the part that broke my brain: Every other pipeline ranks candidates by how sure the model is about them. This lab reads that same confidence as proof somebody already got there. Same model. One version optimises for the middle of what's known. The hard part was never generating molecules. It was noticing that the confident ones are the crowded ones ↓

Codio

11,228 Aufrufe • vor 6 Tagen

A Jev engineer hasn’t waited on a CI pipeline in three months, and his changes still reach production faster and safer than the rest of the team’s He never sped the pipeline up. He routed around it, letting every change prove itself on live traffic users never see. > SHADOW - each change runs beside production on a mirrored copy of real traffic > JUDGE - the Jev system compares both outputs request by request, never by averages > SWAP - a change that matches or beats live behaviour goes in, with a 200 ms rollback armed CI was built for a world where real traffic was too risky to touch, so it tests against guesses about what users do. Shadow traffic removes the guess. The new code sees exactly what users send, and its answers simply never reach them. The comparison is the hard part. Two outputs can differ and both be right, so Jev scores intent instead of exact matches. Most changes clear in minutes. The ones that fail get caught on the exact request that broke them, input attached. The armed rollback is what makes it safe. One bad response and the old path is back before the next request lands. His team still writes tests. They just stopped treating a green checkmark as proof that real users will be fine. His full setup, from the traffic mirror to the rollback trigger, is written up in the article attached here.
0:26

A Jev engineer hasn’t waited on a CI pipeline in three months, and his changes still reach production faster and safer than the rest of the team’s He never sped the pipeline up. He routed around it, letting every change prove itself on live traffic users never see. > SHADOW - each change runs beside production on a mirrored copy of real traffic > JUDGE - the Jev system compares both outputs request by request, never by averages > SWAP - a change that matches or beats live behaviour goes in, with a 200 ms rollback armed CI was built for a world where real traffic was too risky to touch, so it tests against guesses about what users do. Shadow traffic removes the guess. The new code sees exactly what users send, and its answers simply never reach them. The comparison is the hard part. Two outputs can differ and both be right, so Jev scores intent instead of exact matches. Most changes clear in minutes. The ones that fail get caught on the exact request that broke them, input attached. The armed rollback is what makes it safe. One bad response and the old path is back before the next request lands. His team still writes tests. They just stopped treating a green checkmark as proof that real users will be fine. His full setup, from the traffic mirror to the rollback trigger, is written up in the article attached here.

wast3

114,539 Aufrufe • vor 23 Tagen

A Jev engineer hasn’t waited on a CI pipeline in three months, and his changes still reach production faster and safer than the rest of the team’s He never sped the pipeline up. He routed around it, letting every change prove itself on live traffic users never see. > SHADOW - each change runs beside production on a mirrored copy of real traffic > JUDGE - the Jev system compares both outputs request by request, never by averages > SWAP - a change that matches or beats live behaviour goes in, with a 200 ms rollback armed CI was built for a world where real traffic was too risky to touch, so it tests against guesses about what users do. Shadow traffic removes the guess. The new code sees exactly what users send, and its answers simply never reach them. The comparison is the hard part. Two outputs can differ and both be right, so Jev scores intent instead of exact matches. Most changes clear in minutes. The ones that fail get caught on the exact request that broke them, input attached. The armed rollback is what makes it safe. One bad response and the old path is back before the next request lands. His team still writes tests. They just stopped treating a green checkmark as proof that real users will be fine. His full setup, from the traffic mirror to the rollback trigger, is written up in the article attached here.
0:24

A Jev engineer hasn’t waited on a CI pipeline in three months, and his changes still reach production faster and safer than the rest of the team’s He never sped the pipeline up. He routed around it, letting every change prove itself on live traffic users never see. > SHADOW - each change runs beside production on a mirrored copy of real traffic > JUDGE - the Jev system compares both outputs request by request, never by averages > SWAP - a change that matches or beats live behaviour goes in, with a 200 ms rollback armed CI was built for a world where real traffic was too risky to touch, so it tests against guesses about what users do. Shadow traffic removes the guess. The new code sees exactly what users send, and its answers simply never reach them. The comparison is the hard part. Two outputs can differ and both be right, so Jev scores intent instead of exact matches. Most changes clear in minutes. The ones that fail get caught on the exact request that broke them, input attached. The armed rollback is what makes it safe. One bad response and the old path is back before the next request lands. His team still writes tests. They just stopped treating a green checkmark as proof that real users will be fine. His full setup, from the traffic mirror to the rollback trigger, is written up in the article attached here.

Beaver

21,131 Aufrufe • vor 22 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 14 Tagen

AI can write more code than any team can review by hand, and a pull request can look fine while hiding a security issue or missing a requirement. In our new short course, AI Code Review, built in collaboration with Qodo and taught by Nnenna, you'll learn the practices that make AI code review effective: review before you open a pull request, give the reviewer full context about your codebase, and triage findings by risk. Then you'll build your own review agent, from a context engine that finds the right code to a team of specialized reviewers. Enroll for free:
1:39

AI can write more code than any team can review by hand, and a pull request can look fine while hiding a security issue or missing a requirement. In our new short course, AI Code Review, built in collaboration with Qodo and taught by Nnenna, you'll learn the practices that make AI code review effective: review before you open a pull request, give the reviewer full context about your codebase, and triage findings by risk. Then you'll build your own review agent, from a context engine that finds the right code to a team of specialized reviewers. Enroll for free:

DeepLearning.AI

56,896 Aufrufe • vor 3 Monaten

Security Swarm sends a swarm of parallel Devins through your codebase to build a threat model, hunt down real, exploitable vulnerabilities (even ones chained across files), prove them in a sandbox, and hand you the fix as a pull request. Here's how it works:
3:17

Security Swarm sends a swarm of parallel Devins through your codebase to build a threat model, hunt down real, exploitable vulnerabilities (even ones chained across files), prove them in a sandbox, and hand you the fix as a pull request. Here's how it works:

Devin Developers

15,587 Aufrufe • vor 25 Tagen

nobody reads pull request descriptions, so we made videos when Polylane submits a PR to you, we attach a video walkthrough explaining exactly what the issue is, and how it fixed it Vi Tran wrote down how we built it here:
2:24

nobody reads pull request descriptions, so we made videos when Polylane submits a PR to you, we attach a video walkthrough explaining exactly what the issue is, and how it fixed it Vi Tran wrote down how we built it here:

boris

11,565 Aufrufe • vor 19 Tagen

Continuous batching in LLMs, clearly explained: (a popular LLM interview question; bookmark this) In traditional ML inference, a batch is a matrix. Every input is padded to the same length, one forward pass runs, and every row finishes at the same moment. LLM decoding does not work that way. One forward pass produces one token per sequence, so a request needs as many passes as it has output tokens, and nobody knows that count until the model emits a stop token. Under static batching, membership is fixed when the batch starts. A request that finishes in 30 tokens holds its slot until the slowest request in the same batch finishes at 400. The GPU keeps paying the full weight read for a batch that is mostly empty. Loading model weights out of HBM costs the same whether four slots are producing tokens or one. Continuous batching moves the decision boundary. Instead of scheduling once per batch, the scheduler runs a single forward pass, gets control back, and decides again. A finished request leaves at the next iteration boundary, and a queued request takes its slot right there. No slot stays reserved for work that is already done. Anyscale benchmarked both OPT-13B on a single A100. With uniform generation lengths, the two policies came out about level (as expected), and as output length variance rose, static batching fell to around 81 tokens per second while vLLM reached 23x the throughput of naive Hugging Face serving. Variance drives the entire gap. Production traffic mixes 30-token replies with 400-token ones, which is exactly the condition static batching handles worst. None of this alters the model. vLLM, SGLang, TGI, and TensorRT-LLM all run it by default, and NVIDIA ships the same mechanism under the name in-flight batching. The animation below runs both policies on the same 16 requests and the same 4 slots, stepping in lockstep. The only difference is when a new request is allowed in. To dive deeper into continuous batching specifically, I wrote a full breakdown of the scheduler underneath it. It covers what happens between two forward passes, how tokens get handed out against a fixed budget, why the scheduler needs no separate path for prefill and decode, and what preemption costs you when the KV cache fills up mid-generation. Read it below.
0:29

Continuous batching in LLMs, clearly explained: (a popular LLM interview question; bookmark this) In traditional ML inference, a batch is a matrix. Every input is padded to the same length, one forward pass runs, and every row finishes at the same moment. LLM decoding does not work that way. One forward pass produces one token per sequence, so a request needs as many passes as it has output tokens, and nobody knows that count until the model emits a stop token. Under static batching, membership is fixed when the batch starts. A request that finishes in 30 tokens holds its slot until the slowest request in the same batch finishes at 400. The GPU keeps paying the full weight read for a batch that is mostly empty. Loading model weights out of HBM costs the same whether four slots are producing tokens or one. Continuous batching moves the decision boundary. Instead of scheduling once per batch, the scheduler runs a single forward pass, gets control back, and decides again. A finished request leaves at the next iteration boundary, and a queued request takes its slot right there. No slot stays reserved for work that is already done. Anyscale benchmarked both OPT-13B on a single A100. With uniform generation lengths, the two policies came out about level (as expected), and as output length variance rose, static batching fell to around 81 tokens per second while vLLM reached 23x the throughput of naive Hugging Face serving. Variance drives the entire gap. Production traffic mixes 30-token replies with 400-token ones, which is exactly the condition static batching handles worst. None of this alters the model. vLLM, SGLang, TGI, and TensorRT-LLM all run it by default, and NVIDIA ships the same mechanism under the name in-flight batching. The animation below runs both policies on the same 16 requests and the same 4 slots, stepping in lockstep. The only difference is when a new request is allowed in. To dive deeper into continuous batching specifically, I wrote a full breakdown of the scheduler underneath it. It covers what happens between two forward passes, how tokens get handed out against a fixed budget, why the scheduler needs no separate path for prefill and decode, and what preemption costs you when the KV cache fills up mid-generation. Read it below.

Avi Chawla

16,140 Aufrufe • vor 2 Monaten