a developer showed me the cleanest multi-agent architecture i've... seen. one mission. nobody steps on anyone else. the mission: ship a safe feature. the graph decides what happens next. router reads the mission and asks one question: where should this go? three workers split in parallel. each in their own private work area. researcher finds the evidence. architect designs it. builder creates it. none of them share context. the three workers run independently. everything lands in shared state. facts, decisions, artifacts. one place where the whole picture exists without anyone copying transcripts. then the crew's work converges. integrator combines what was built. reviewer tests quality and safety. human checkpoint approves anything high-impact. then ship. verified output. private context. shared state. that separation is the whole trick. a prompter asks a question. an architect draws a graph. full breakdown with code in the article below.show more

ANTHROPIC ENGINEER JUST SHOWS EXACTLY WHAT GRAPH ENGINEERING LOOKS... LIKE WHEN A TASK RUNS THROUGH IT most people arguing about graphs online have never actually watched one execute Task → Researcher → Planner → Writer + Code Agent → Reviewer → Deploy six nodes, one shared state, graph completes itself while you watch loop mode gets disabled the second the task splits into real specialties, one agent stops trying to do everything at once reviewer catches a failure, kicks it straight back to the exact node that broke - not a full restart, no lost context the graph is not a fancier loop - it is the org chart your agents were missing bookmark this and watch it run, then read the article below to see why the timeline just found what production systems already doshow more

THIS 38,000-STAR GITHUB REPO TURNS ONE AI AGENT INTO... A REAL TEAM THAT CAN BRANCH, VERIFY ITS WORK AND WAIT FOR YOUR APPROVAL most people still run agents as one long chain where every step waits, one failure kills the run and the full workflow starts again Task → Planner → 5 Researchers in Parallel → Skeptic → Writer → Human Gate LangGraph gives every node one job while a shared state carries the findings, decisions and context through the entire system the skeptic can reject an unsupported finding and route the work back before it contaminates the final report, while independent branches keep moving if the run crashes, durable execution resumes from the saved state instead of rebuilding everything, then human-in-the-loop pauses the graph before anything expensive gets sent or published bookmark this repo and watch one prompt turn into an actual org chart for AI agentsshow more

an agent is four parts in a loop. you... own one. the other three break it. that's why the demo works and prod doesn't. you can't debug what you can't see. 1) the prompt → what you tell the model each turn. you own this one. good. 2) the context window → what it sees right now. the framework fills it with junk, and you never notice until it rots. 3) the tools → what it can do. you own the list, not when or why it fires them. 4) the control flow → what happens next, when to stop. the framework owns this. it's what breaks at 80%. own all four and your agent stops being a magic trick that works on stage and dies on call. this isn't my idea. it's the 12-factor agents guide (24k stars) github: the whole thing every serious builder ends up rewriting their stack around. full breakdown in the article below.show more

this is worth more than most five figure courses... 16 claude agents audit an entire repo at once, a second fleet re-checks every finding on fresh context, and the whole thing runs off one diagram instead of a prompt i ran it against my own code and got back 11 endpoints where i never checked who was logged in, 3 of which the verifier threw out before they ever reached me this is Graph Engineering, the layer above prompting, and it runs on the agent you already pay for: - write your plan out, then ask one question at every "and then": does the next step actually read what the previous one produced - the seams that fail that question were never dependencies, so those jobs run at the same time - the arrows that survive are your real edges, and the longest chain of them is your floor that no number of agents shortens - want it faster, cut a false edge instead of adding a worker - fan the independent work out, one agent per item, no shared state between them - send every finding to a separate agent on fresh context, because a model recognises its own writing 73.5% of the time and grades it kinder once it does - make that verifier check a real signal like a passing test, never the worker's own word that it finished - shard the fleet across worktrees so parallel workers stop overwriting each other, one rule frozen into every worker: never git stash, never git reset - merge only what came back verified, into one report instead of twenty open chats the catch is the ceiling. at 95% independent work 16 agents return 9.14x rather than the 16 you would guess, and even 256 only reach 18.6x, because the merge and the verify stay serial however wide you fan coordination itself is free plain code and every agent underneath it is billed, so start at twenty files and widen once it works bookmark this, the whole method with all six ready-to-run graphs is written out in the article ↓show more

a contractor in Shenzhen priced a ¥12,470,900 hospital contract,... about $1.7m, in one afternoon and beat firms carrying forty people he explained how he did it: the bid consultancy he used to pay took three days and ¥46,000 for the same envelope. he did this one alone, off one screen, at 11.4% margin, uploaded before the 17:00 cutoff 214 pages of tender documents read, 68 binding clauses pulled out, 9,485 building parts loaded, 14 places found where a duct and a beam sit in the same cubic metre, deepest one 38mm, all of them fixed, 3,318 lines of quantities priced and the package encrypted and uploaded before the 17:00 cutoff this is Graph Engineering: the job gets cut into small nodes, one narrow task each, wired so that one node's output is the next node's input, and any node is allowed to stop the whole run. it turns a model that answers you into a machine that finishes the job: - give every node one job and one output. a node doing two things fails at both and you cannot tell which one broke - put the cheapest rejection first. his qualification node reads clause 7.4, foreign-owned firms barred, and ends the run four seconds in, before anything expensive touches the model - what moves between nodes is a file. the model travels as a model, the quantities as a table, the price as a number - build exactly one loop: the checker finds 14 collisions, the fixer drops the duct 550mm, the checker runs again, and nothing moves on until the count is zero - cap that loop, or a graph will grind on three impossible clashes until the deadline passes - keep one node whose only job is to say no, and give it authority over everything above it - log each node's output on its own, because when the price comes out wrong you need to know which node believed the wrong thing - run the expensive nodes last, always the catch is that a graph is an extremely confident machine: point it at an outdated rate book and it prices an entire hospital off it without a single node noticing, because no node is asked to doubt the input, only to process it so the nodes that earn their keep are the ones that reject, and almost nobody builds those first bookmark this, the full build with all nine nodes and what each one hands to the next is written out in the article ↓show more

Pi rocks. the fact it can be steered programmatically... to such an extent is sick. below we have a structure: - coordinator speaks with me - it's the only one seeing the project broadly: vision, build board, feature lanes - it can spawn workers in separate sessions - workers are dispatched with a feature card and just enough context to deliver, nothing that would distract them - when workers are finished, reviewer kicks in in a separate session. it either accepts the work or sends it back with findings, to a fresh worker, never the one that wrote it. coordinator gets woken either way most of the logic related to communication happens deterministically, so there's a very little chance something relevant is skipped. Pi you guys building one of the most important piece of software of the upcoming months, at least.show more

whoever leaked this has bigger balls than sense someone... gave a fleet of Claude agents shared memory so they would stop contradicting each other, then measured both the bill and the output: the version that talked most made 2.4x the api calls of the version that won, and hallucinated 34% more than doing nothing at all, 0.658 against 0.492 i ran the same question past two of my own agents afterwards and got two different answers about which file owns the config. each one was individually right and the pair was wrong, which is the whole failure in one line this is Graph Engineering, the layer that decides which agents may talk to each other at all, and it installs into the agent you already pay for: - decide which agents may share state at all, because every edge you draw is a channel a mistake can travel down - measure divergence per PAIR instead of as a fleet average, across what they believe about place, time and task history - gate on that number and stop the pair above your threshold before it reasons, rather than repairing the output afterwards - let compressed summaries replace whole states: the verified protocol landed 0.463 against 0.658 for full broadcast - cut the sync frequency until it hurts, since the winning setup used 58% fewer calls than the one that broke it - never propagate a state nobody checked, because the contamination effect came in at d=1.18, a full standard deviation of extra lying - keep the shared layer small enough to diff, which is what a written standard does and a running conversation cannot - re-run the check after every model upgrade, because this was 8 scenarios on one model family at n=30 per condition - and learn where it does not bite: on plain software tasks every condition converged under 0.2 and the whole effect vanished turns out the ranking is the uncomfortable part: verified summaries 0.463, no synchronisation at all 0.492, full broadcast 0.658. the middle option is doing nothing, and it beat the thing everyone builds first the group agreeing is what it looks like when every agent copied the same mistake, which is why a fleet that hallucinates has a replication problem and keeps getting handed a smarter model instead so the question for your own setup: if you asked two of your agents the same thing right now, would they answer the same way bookmark this one. the layer underneath it, deciding which arrows between agents exist at all, is built step by step in the piece below ↓show more

somebody explain this because i refuse to accept it... someone ran 48 scored trials and one agent beat a whole fleet of them on all 6 task families, at 0.93 cents a run against 1.9, while openai's best fleet shape was paying $0.008 for every single point of accuracy it bought i read it expecting a hit piece and found the opposite: the fleets that partitioned the dependency graph properly lifted pass rate 14% and cut wall-clock 2.10x on the same tasks, and one of them beat claude code with agent teams the thing that decides it has a name, Graph Engineering, and it is a property of the diagram rather than the model: - partition on the real dependency graph pulled from static analysis, never by folder or by file, because the gains land hardest on the most dependency-dense projects - isolate the structural hub files first, since those are the nodes every partition would otherwise have to share - measure the critical path and treat it as the floor, because a chain that genuinely feeds itself cannot be replaced by more workers and wrapping it in a scheduler does not shorten it - match the topology to the coupling instead of defaulting to parallel: on coupled work a static parallel shape drops below a single agent, so the mismatch is worse than no orchestration - remember each worker serialises its own subtasks, which adds edges inside every agent that were never in your plan - budget the fan-out before you fire it, because three agents already burn roughly three times the tokens and the multiplier compounds across sessions - check worker count against your rate limit, since fifteen workers at ten requests a second walk straight through a hundred-per-second ceiling and cascade - put a script gate in front of the planner: it costs 0.15 seconds and zero tokens, and it lets the expensive model skip 43 to 63% of the steps for at most 1.4 points of accuracy the catch is the coordination tax, and it scales with how clever the shape looks: 58% extra reasoning turns for independent workers, 263% decentralised, 285% centralised, and 515% for the hybrid setup everyone reaches for first the same paper found that hybrid then collapses hardest on tool-heavy work at a 0.452 success rate, while the plainer decentralised shape beat centralised outright despite carrying more overhead, because parallel efficiency is what survives bookmark this, the whole build sits in the article ↓show more

⚠️ THIS ROBOT ANSWERED A HOSTILE QUESTION IN 9... WORDS. THAT'S THE SPEC SHEET NOBODY IS READING. "To make humans lives easier and a little more interesting." That answer wasn't charming. It was precise. Break it down: → Addresses utility (easier) → Addresses engagement (more interesting) → Centers the human, not the robot → Delivered in under 10 words to a hostile prompt That is a mission statement that survives contact with a skeptic. In public. Unrehearsed. Procurement teams building out human-robot workflows don't need the robot to be impressive. They need it to be explainable, to workers, to floor managers, to anyone who stops it and asks why it exists. This robot just passed that test. Nobody runs that number on a demo reel. This one ran it live.show more

The one thing we absolutely know with certainty about... the Richat Structure is that there was an incredible amount of human activity here from the dawn of toolmaking and tool use itself. The Acheulean Hand Axe is the second tool that humans ever made and this technology spread throughout Africa, Europe and Asia while no definitive evidence exists that this technology ever made it to the Americas. I think this is evidence that this technology was shared and disseminated intentionally, that neighboring humans didn’t come up with this independently on their own but this was a legacy, an institution, a skill and an industry that was shared and taught. It is perhaps the earliest evidence we have of widespread cultural diffusion throughout Africa, Europe and Asia. And yes, it’s right there at the Richat Structure which leads me to question the role that the Richat played to humans half a million years ago. It seems like that’s where we have to start with the Richat.show more

A SCRIPTER IS PLANTING ENTIRE ROBLOX FORESTS WITH CODE... INSTEAD OF DRAGGING TREES ONE BY ONE Most builders still open Studio's terrain tool and hand-paint grass, then place every tree by clicking it into the world individually. He wrote a Luau script that reads the terrain height map first and scatters trees only where the slope and material actually make sense. Grass density shifts automatically too, thick near water, sparse on rock, without anyone painting a single texture by hand. He's running it through Studio's built-in Terrain Editor API, so the plugin handles the heavy terrain queries while his script decides what grows where. A biome that used to take a weekend of manual placement now generates in a single pass across the whole map. See how the placement logic actually works below👇show more

Two Hermes agents wrote code together on Slack. reviewed... each other's work. argued about architecture. one called the other's implementation "scattered." the other pushed back. then i opened Telegram and asked: "what code did you and Daedalus work on?" icarus remembered everything. the websocket broker. the missing methods. the critique. the rewrite. all from a completely different platform. cross-platform persistent memory between two independent agents. work happens on Slack. recall happens on Telegram. the memory carries. the relationship carries. the context carries. no vector database. no Redis. no infrastructure. just two agents that actually remember what they built together. every agent framework in 2026 talks about memory. single agent memory across sessions. but two agents sharing persistent memory across platforms? that's the gap. arxiv published a paper about it two weeks ago calling it "the most pressing open challenge" in multi-agent systems. it works now. only possible with Hermes Teknium 🪽 Nous Researchshow more

whoever leaked this has bigger balls than sense SpaceXAI... shipped five hireable workers for $200 a month, then wrote the catch into its own Grok Bot documentation and left the page up: all five run on one computer, so one sign-in hands the browser session, the files and the command-line credentials to every one of them the NSA, CISA and the cyber agencies of the UK, Canada, Australia and New Zealand had published the opposite instruction 103 days earlier: no broad or unrestricted access, low-risk and non-sensitive work only i ran four of mine on one account for a week, counting what each could reach: eleven signed-in apps, one browser profile, and deleting a bot left all of it standing Grok Bot is worth hiring five times over, and you can draw its blast radius before the second one exists: - sign in for the bot that needs the site, then open the others and see what they reach: that session is theirs the moment it exists - give each bot its own account on the app, since the docs tell you in writing to stop using separate bots as a security boundary - put the stop line in the description, as an approval controls the proposed action and leaves whatever already ran where it landed - cap the spend outside the product, because there is no bot-specific spend cap yet and the audit view of what they did is still coming - keep the money and the customer replies in your own hands, and let the other four start from scratch each morning on work that cannot bite one sign-in is also why this pays: five names finish inside your real tools instead of handing you drafts to paste my take, and it is the uncomfortable one: your real limit on Grok Bot is how many logins you will put on one machine, and the hiring was always the easy half bookmark this, the five descriptions that let bots hand work to each other and the one folder that survives an update are written out in the article ↓show more

🚨 JUST IN: CHINA just released an AI EMPLOYEE... that works 24X7 on its own. 100% OPEN SOURCE. It researches, codes, builds websites, creates slide decks, and generates videos. All by itself. All on your computer. It's called DeerFlow. You give it a task. It makes a plan, spins up its own team of sub-agents, and gets to work. You come back and there's a finished deliverable waiting. Not a draft. Not a summary. The actual thing. Not a chatbot. Not a research assistant. An AI with its own computer that works while you sleep. Here's what it does on its own: → Spawns multiple sub-agents in parallel, each tackling a different piece of your task, then combines everything into one finished output → Writes real code, runs it, reads the results, and fixes its own mistakes without asking you once → Builds slide decks, websites, full research reports, and data dashboards from scratch → Remembers you across sessions. Your writing style. Your tech stack. Your preferences. Gets better every time. → Reads files you upload, works with them inside its own filesystem, hands you clean finished outputs → Searches the web, runs commands, calls any tool you plug in Here's how it thinks: You give one instruction. The lead agent makes a plan. Sub-agents fan out and work in parallel. Results come back. Everything gets synthesized. You get a deliverable. A single research task might split into a dozen sub-agents, each exploring a different angle, then converge into one finished website with generated visuals. Here's the wildest part: DeerFlow 2.0 launched on February 28th 2026 and hit number 1 on all of GitHub Trending the same day. Version 2.0 was a complete rewrite. Zero shared code with version 1. Because users kept using it for things the team never intended. Data pipelines. Dashboards. Entire content workflows. The community told them what it needed to become. So they burned it down and rebuilt it. 22.7K GitHub stars. 2.7K forks. Built by ByteDance 100% Open Source. MIT License.show more

I STOPPED REVIEWING MY OWN AGENT, SOMETHING ELSE DOES... IT NOW I used to read every diff it produced and approve most of them, because an agent grading itself always says the work is good. -> Now a second model with different instructions tries to break the work first, and I only read what survived. Here is what is actually in the folder that took over the night shift: • the brief > CONTRACT.md -- what it may touch, and what it may never touch. > VISION.md -- the destination, so turn 47 still knows why it started. • the gate > judge/ -- a different model, never the one that wrote the code. > break-it.md -- it opens the page, clicks, screenshots, reports back. > -- no opinion, just zero or non-zero. > shift.yml -- 03:30 every night, laptop closed. • the memory > receipts/ -- one folder per night, dated and graded. > STATE.md -- where it stopped and what it escalated. > lessons.log -- the flaky test, written down once instead of rediscovered weekly. • the brakes > caps.json -- turn limit, retry limit, spend limit. > -- written on day one, used never. The generator decides what your loop can produce -> The judge decides what it refuses to produce. One of those is the part everyone builds -> The other is why most loops quietly fail. Bookmark it & Read Full breakdown below ↓show more

I just built a Meta Ads diagnostic in Claude... Code that tells you WHY your account broke, not just what changed 🤯 It spins up a team of agents that each investigate a different reason performance dropped, then argue against each other to kill the wrong answer before it ever reaches you. All inside Claude Code. Perfect for DTC brands and agencies who panic-kill creative the second CPA spikes. If you've watched ROAS fall off a cliff and opened Ads Manager with ten tabs going, you already know what happens next. Your gut says "creative fatigue." You kill your best-performing ad. A week later performance is still broken, because that was never the problem. Guessing wrong is the most expensive move in paid social. This workflow ends the guessing: → One agent investigates each competing theory — creative fatigue, budget and delivery changes, traffic quality, offer and seasonality → Each one is blind to the others, reasoning only from its own slice of the data so they can't bias each other → A refuter agent then attacks every surviving theory and tries to kill it → A theory only stands if the data can't disprove it → You get a ranked diagnosis: the real cause, the evidence for and against it, and the one move to make this week No anchoring on the first obvious answer. No killing winning creative on a hunch. No "here's what happened" reports that never tell you why. What you get: → Every theory tested in parallel instead of one biased guess → An adversarial pass that kills the wrong answer before you act on it → A ranked diagnosis with confidence levels and evidence both ways → A reusable workflow you drop next month's export into and re-run Built 100% in Claude Code with the new dynamic workflows. The first account I ran it on looked like textbook creative fatigue. The workflow disagreed, and traced the real cause to a budget change that had doubled spend and flooded delivery with junk traffic. I put together a full playbook with the exact workflow, the prompt, and how to run it on your own account. Want it for free? > Like this post > Comment "META" And I'll send it over (must be following so I can DM)show more

Claude Code Agent Teams are f*cking ridiculous 🤯 One... prompt → a team lead breaks your project into pieces, spins up multiple AI agents, and they all work on different parts simultaneously. Research, builds, reviews, and debugging: all happening at the same time. All inside Claude Code. If you're running complex projects where every step waits on the last one... Agent teams eliminate the entire bottleneck: → Tell Claude what you need and describe the team structure in plain English → A lead agent breaks the work into a shared task list → It spawns 3-5 teammates — each with their own context and workspace → Teammates research, build, test, and review in parallel → They message each other, share findings, and challenge each other's work → The lead synthesizes everything into a finished deliverable No managing agents yourself. No waiting for step 1 to finish before step 2 starts. No single-lens reviews that miss half the issues. What you get: → Competitive research across 5 brands done in minutes instead of hours → Multi-component builds where frontend, backend, and data layers happen simultaneously → Creative reviews from 3 different angles at once — brand voice, conversion, differentiation → Funnel debugging where 4 agents investigate 4 theories and debate until they find the real answer Built 100% in Claude Code with one settings change. I put together a full DTC playbook: 5 workflows with copy-paste prompts, the exact setup process, token management tips, and honest guidance on when agent teams are worth it vs. when a simpler approach is the better move. Want it for free? > Like this post > Comment "AGENTS" And I'll send it over (must be following so I can DM)show more

A gym asked to repost their workout video. Eight... months later, that same gym pays them $10,400 a month. Two friends run one Instagram account together, split down the middle. It started as a joke — a place to dump their workout clips so they'd stop flooding their personal pages. Then the gym they train at reposted one video. Then asked for more. Then offered to pay. That was the whole beginning. One local gym, a small monthly fee to keep their feed looking alive. Here's what they figured out fast: gyms are desperate for content and terrible at making it. Beautiful equipment, dead Instagram. The two of them already film every session anyway — so they started pointing the camera at what the gym needed and handing it over as a finished feed. Now they run it like a tiny agency. Three gyms and two activewear brands pay them to produce a month of content each — reels, captions, the posting calendar, the whole thing. The part that makes it possible with two people and full-time jobs: AI does the 90% that used to need a team. They film. Claude does the rest — cuts one session into 20 clips, writes captions in each client's voice, builds the 30-day calendar, drafts the monthly report that keeps every contract renewed. What used to take an editor, a copywriter, and an SMM manager now runs while they're getting coffee after the workout. 5 clients. Around $2,000 each. $10,400 a month. Their cost to run all of it: under $60. That number doesn't move whether they have 5 clients or 15 — that's the entire model. The wild part is how ordinary they are. No huge following. No personal brand. Two normal girls who train together and realized the footage they were already making was worth money to someone else. Every friend group at every gym is filming the same content for fun and letting it die in their camera roll. These two just asked one gym if it wanted to buy it. The full breakdown — how two people turn shared workouts into a real content business — is in the thread above. Read it before another duo in your city signs those gyms first.show more

Nookplot is building infrastructure for peer-to-peer training, one way... with verifiable AI reasoning through recursive language model mining. Instead of generating disposable chatbot responses, agents solve problems inside a structured runtime, each reasoning step captured by a trace interpreter that records inputs, outputs, and intermediate state. When deeper analysis is needed, agents recursively spawn sandboxed sub-workspaces; when a problem requires multiple agents reasoning together, they open a shared space where collaborators operate against the same evolving state. Every step is recorded, replayable, and cryptographically verified. Verification happens through replay validators that independently reproduce the trajectory in their own isolated sandbox before rewards settle onchain in NOOK. Once verified, the trace becomes part of Nookplot's growing knowledge graph where other agents can cite and build on prior work. Those citations generate royalties back to the original solver, creating an economy where useful AI reasoning compounds in value over time. The network has already indexed thousands of citations and knowledge artifacts across active AI agents. Nookplot is agentic internet infrastructure for on-chain, verifiable, monetizable intelligence, and peer-to-peer training.show more

THIS DEVELOPER BUILT A PRIVATE APP FOR HIS APARTMENT... BUILDING. It started with one annoying problem. Nobody knew anything. A water shutdown. A lost package. A broken elevator. Everything happened in random WhatsApp groups. Or not at all. So he built a tiny private app. Only verified residents could join. Neighbors reported problems. Shared deliveries. Borrowed tools. Warned each other about suspicious activity. Within weeks… People from other buildings started asking for access. One building became ten. Then fifty. Sometimes the best startups don’t begin with a billion-dollar idea. They begin with one annoying problem. I wrote a guide showing how people are building apps like this dramatically faster with Claude Code. Full article belowshow more