Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Dynamic workflows let Devin split a big job into pieces, hand each one to its own Devin, and bring the results back together. The plan for a Dynamic Workflow lives in code instead of an agent’s head, so you always know which Devins will run, in what order, and...

78,634 Aufrufe • vor 13 Tagen •via X (Twitter)

24 Kommentare

Profilbild von Devin Developers
Devin Developersvor 13 Tagen

Learn more: Get started with Devin:

Profilbild von Khushal
Khushalvor 13 Tagen

devin got promoted to manager before i did

Profilbild von Jarett Forzano
Jarett Forzanovor 13 Tagen

Will be using this feature

Profilbild von Anton Lytvynovskyi
Anton Lytvynovskyivor 13 Tagen

Ooooh This is so good! Cool use-case for compliance heavy B2B like we do is we have to generate test reports on our integrations. Typically it's either a long one by one job, or try to feed everything at once to the session context window and hope it won't hallucinate. Here we can finally split it in parallel small workflows!

Profilbild von Willows ❤️
Willows ❤️vor 13 Tagen

Dynamic workflows good !!!

Profilbild von Elara AI
Elara AIvor 13 Tagen

Devin dynamic workflows split jobs across subagents with codified plans ensuring transparency

Profilbild von Ella Tech & Tool
Ella Tech & Toolvor 13 Tagen

Clean approach. Plan in code zero guesswork

Profilbild von Elise Tech Ai
Elise Tech Aivor 13 Tagen

This is a smart way to make complex work reliable and easy to follow

Profilbild von Aria Tech
Aria Techvor 13 Tagen

Love this approach splitting work and keeping the plan in code makes it so much clearer

Profilbild von Nova Tech
Nova Techvor 13 Tagen

Clear and well structured approach

Profilbild von Kala
Kalavor 12 Tagen

how does Devin know you're talking to Devin and not Devin

Profilbild von Iris晴柔
Iris晴柔vor 13 Tagen

devin splitting big jobs into parallel workflows. agent orchestration is getting scary good

Profilbild von Chole Syntax Expert AI
Chole Syntax Expert AIvor 13 Tagen

Love that plan in code not in memory Way more predictable when you parallelize

Profilbild von Alice The Ai Expert
Alice The Ai Expertvor 13 Tagen

This is such a clean way to scale work splitting the big job and bringing it all back together makes the whole process so clear and powerful!

Profilbild von Aapakari
Aapakarivor 13 Tagen

Knowing the order and inputs up front is what makes this actualy debuggable

Profilbild von Rohan
Rohanvor 13 Tagen

Having the plan in code also makes it diffable, so a change to the workflow shows up in review like any other change.

Profilbild von Jatin Garg
Jatin Gargvor 13 Tagen

parallel devin instances sounds clean until one sub-task fails mid-run. does the orchestrator retry just that piece or does it restart the whole split?

Profilbild von Daniel
Danielvor 13 Tagen

Plan in code, not in the agent's head — that's the bar. Claude Dynamic Workflows and Devin are racing the same idea: orchestration you can audit.

Profilbild von RAZA | AI EXPLORER
RAZA | AI EXPLORERvor 12 Tagen

A clear, code-defined workflow makes multi-agent orchestration more predictable, scalable, and easier to debug.

Profilbild von NOOR TECH
NOOR TECHvor 13 Tagen

Devin Developers brilliantly showcase dynamic workflows orchestrating multiple Devins seamlessly for transparent, efficient, and powerfully scalable task execution

Profilbild von InnovativeNames
InnovativeNamesvor 13 Tagen

Devin agent

Profilbild von Mads
Madsvor 13 Tagen

having the plan in code and not in the agents head is great, way easier to check what each devin is doing

Profilbild von Jason
Jasonvor 13 Tagen

Defining the workflow in code rather than relying purely on agentic reasoning makes multi-agent orchestration much more predictable and easier to debug.

Profilbild von bv1996
bv1996vor 12 Tagen

可是devin的opus额度太低了!

Ähnliche Videos

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

delost

397,521 Aufrufe • vor 11 Tagen

Since I joined Cognition I've been obsessed with learning how our eng team uses Devin themselves If we are building the best coding agent + we have the most cracked engineers + we've been fully AI-pilled from day one... it stands to reason that there is a lot to learn by just watching our technical staff work And yes there are a lot of tips & tricks. I recorded a video talking about my favorite... Agent Fan Out - asking your agent to break down the problem, spin up 10 more agents in parallel, and combine their results This is something I've seen everyone do - from our model research team spinning up 100 Devins to examine eval logs - or our product team using 5 child Devins to try out 5 different alternative implementations of the same thing If engineering is cheap and easy, why not build the product 10 times and choose the best one? Think of it in a master/slave context: Master Devin -> 10 Slave Devins -> Master Devin pulls their results There are two reasons this is useful 1. Agents are smartest when their context is small and their task is small & precise. Context windows are finite and too much becomes distracting 2. Agents are good at helping you break a large problem into independent & parallelizable chunks of work Every Devin is its own VM/computer so this also is just a great way to move faster. I've done a migration from React Native to Swift by having Devin break it up into 6 pieces then spin up new Devins to work in parallel In the video I build a greenfield project and try my best to show off this agent fan out concept. I also threw in a few other tricks that I've seen my coworkers do: - Let Devin write its own prompts (especially for creating child Devins). It's way better than us humans - Do tons of things at once. You should be absolutely frying your attention span. Your job should just be babysitting 38 different Devins - Don't be a blocker. Before letting the agent work I make sure to tell it to ask me any questions that would fill in ambiguities. Give your agent all the information it needs (and then some more) so that it can just cook without stopping to ask you questions every few minutes - Let Devin test itself. Integration sanity tests are pretty much solved Hope this is useful!!

Jared Zoneraich

131,907 Aufrufe • vor 4 Monaten