正在加载视频...

视频加载失败

返回首页

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

leopardracer's profile picture

leopardracer

10,924 subscribers

53,328 次观看 • 3 个月前 •via X (Twitter)

科学技术
LIVE

Anya Rossi• Live Now

Private livecam show

0 条评论

暂无评论

原始帖子的评论将显示在这里

相关视频

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 agents
0:14

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 agents

Gipp 🦅

11,709 次观看 • 3 个月前

loop engineering worked for 6 months. then one pipeline forced a graph a loop is one agent on discover → plan → execute → verify, until a stop condition hits enough for most agent work: failing tests, draft + self-review, inbox triage, one research writeup the break is nameable: if the thing that produced the output also grades it, you don't have quality control, you have a rubber stamp his numbers before the split: 40 drafts 31 passed self-review 18 actually publish-ready on manual read gap = 13 drafts with a passing grade from a biased judge he split one loop into 3 nodes - researcher · sources + notes only - writer · notes + task only · never grades itself - reviewer · separate model call · check the bar · write nothing same 40-draft workload. manual approval 18/40 → 33/40. reviewer rejected 14 with quotable reasons. 2 escalated to human instead of burning tokens forever approval 45% → 82.5%. inference cost +60% worth it when a bad draft costs more than three model calls. not worth it for "fix the failing test" playbook: - 1 law · producer never grades - 1 router · ship / retry / escalate - 1 state object · one owner per field · guarded writes - split the verifier first · cheapest highest-leverage move loop engineering → graph engineering. not five nodes for vibes, one split verifier when the loop starts grading its own homework full contracts, router, and decision function in the article
0:15

loop engineering worked for 6 months. then one pipeline forced a graph a loop is one agent on discover → plan → execute → verify, until a stop condition hits enough for most agent work: failing tests, draft + self-review, inbox triage, one research writeup the break is nameable: if the thing that produced the output also grades it, you don't have quality control, you have a rubber stamp his numbers before the split: 40 drafts 31 passed self-review 18 actually publish-ready on manual read gap = 13 drafts with a passing grade from a biased judge he split one loop into 3 nodes - researcher · sources + notes only - writer · notes + task only · never grades itself - reviewer · separate model call · check the bar · write nothing same 40-draft workload. manual approval 18/40 → 33/40. reviewer rejected 14 with quotable reasons. 2 escalated to human instead of burning tokens forever approval 45% → 82.5%. inference cost +60% worth it when a bad draft costs more than three model calls. not worth it for "fix the failing test" playbook: - 1 law · producer never grades - 1 router · ship / retry / escalate - 1 state object · one owner per field · guarded writes - split the verifier first · cheapest highest-leverage move loop engineering → graph engineering. not five nodes for vibes, one split verifier when the loop starts grading its own homework full contracts, router, and decision function in the article

seeco

14,534 次观看 • 2 个月前

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.
0:20

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.

kocer

31,198 次观看 • 1 个月前

KIMI K3 + OBSIDIAN + LOOP ENGINEERING = A VAULT THAT RUNS ITSELF the core idea: the vault is the loop's state, not the chat window everything Kimi K3 knows lives in a .md file the loop: > capture - a thought lands in 00-inbox > context - K3 pulls links, tags, and neighbouring notes > draft - edits happen inside a git worktree, never the live vault > review - a critic agent checks the diff before anything ships > commit - appended to the vault, nothing gets rewritten the key insight: frontmatter fields like supports, contradicts, and supersedes are graph edges, not metadata - the note format is the write API start with a plain loop, it runs about 2-4x the cost of one direct call > only move to a full graph once state has to outlive the session, several agents need to coordinate, or you have to explain what changed - that jump can run 10-50x one review assistant climbed from 55% to 72% to 84% just by moving through these shapes in order
0:20

KIMI K3 + OBSIDIAN + LOOP ENGINEERING = A VAULT THAT RUNS ITSELF the core idea: the vault is the loop's state, not the chat window everything Kimi K3 knows lives in a .md file the loop: > capture - a thought lands in 00-inbox > context - K3 pulls links, tags, and neighbouring notes > draft - edits happen inside a git worktree, never the live vault > review - a critic agent checks the diff before anything ships > commit - appended to the vault, nothing gets rewritten the key insight: frontmatter fields like supports, contradicts, and supersedes are graph edges, not metadata - the note format is the write API start with a plain loop, it runs about 2-4x the cost of one direct call > only move to a full graph once state has to outlive the session, several agents need to coordinate, or you have to explain what changed - that jump can run 10-50x one review assistant climbed from 55% to 72% to 84% just by moving through these shapes in order

Mr. Buzzoni

10,680 次观看 • 2 个月前

AGENT ARCHITECTURE ROUTES WORK. IT DOES NOT REMEMBER WORK. THAT GAP IS WHY YOUR LOOP KEEPS FIXING THE SAME BUG TWICE. these are two different engineering problems. every agent that silently drifts is missing one of them. architecture answers what runs. harness → loop → graph. it defines the tools, the retries, the branching routes, the approval gates. context ops answer what the run knows. write → read → compress → isolate. it defines what gets saved between attempts, pulled in on read, summarized on overflow, and split across sub-agents. for two months i believed a solid harness plus a verifier loop was enough. my coding agent kept re-discovering the same test failure across retries. the loop was working. it just had nowhere to write what it had already learned. here is the decision rule: if your agent forgets across restarts, add write and read. if it stalls on long tasks, add compress. if two sub-agents step on each other, add isolate. architecture without context ops is a well-routed system with amnesia.
0:12

AGENT ARCHITECTURE ROUTES WORK. IT DOES NOT REMEMBER WORK. THAT GAP IS WHY YOUR LOOP KEEPS FIXING THE SAME BUG TWICE. these are two different engineering problems. every agent that silently drifts is missing one of them. architecture answers what runs. harness → loop → graph. it defines the tools, the retries, the branching routes, the approval gates. context ops answer what the run knows. write → read → compress → isolate. it defines what gets saved between attempts, pulled in on read, summarized on overflow, and split across sub-agents. for two months i believed a solid harness plus a verifier loop was enough. my coding agent kept re-discovering the same test failure across retries. the loop was working. it just had nowhere to write what it had already learned. here is the decision rule: if your agent forgets across restarts, add write and read. if it stalls on long tasks, add compress. if two sub-agents step on each other, add isolate. architecture without context ops is a well-routed system with amnesia.

kocer

12,814 次观看 • 2 个月前

A TEAM JUST DEPLOYED 15 AUTONOMOUS LOOP AGENTS FROM A SINGLE PROMPT USING APPLIED GRAPH ENGINEERING Most developers still manually hardcode multi agent systems, writing separate logic for every individual task. Graph engineering changes this by using a central topological map to spin up all 15 nodes simultaneously. A single 200 word input generates the architecture, routing 120 unique pathways between agents instantly. Instead of failing under conflicting instructions, these loop agents self correct via continuous state sharing. Managing a 15 node mesh requires high token throughput, making this dependent on strict low-] latency API tiers. See exactly how this automated multi agent graph architecture actually operates in real time ↓
0:15

A TEAM JUST DEPLOYED 15 AUTONOMOUS LOOP AGENTS FROM A SINGLE PROMPT USING APPLIED GRAPH ENGINEERING Most developers still manually hardcode multi agent systems, writing separate logic for every individual task. Graph engineering changes this by using a central topological map to spin up all 15 nodes simultaneously. A single 200 word input generates the architecture, routing 120 unique pathways between agents instantly. Instead of failing under conflicting instructions, these loop agents self correct via continuous state sharing. Managing a 15 node mesh requires high token throughput, making this dependent on strict low-] latency API tiers. See exactly how this automated multi agent graph architecture actually operates in real time ↓

slash1s

302,813 次观看 • 3 个月前

Agent Handoff: watch a task move through four agents while the handoff log fills in below. the pulse on the working agent is plain css. the card updates a lot during a run, and putting that pulse in motion kept restarting it mid-loop.
0:15

Agent Handoff: watch a task move through four agents while the handoff log fills in below. the pulse on the working agent is plain css. the card updates a lot during a run, and putting that pulse in motion kept restarting it mid-loop.

Jeet

30,429 次观看 • 2 个月前

Alright, now that we know *what* an agent is, how does it actually work? When you ask for help on a task, the agent plans a series of steps and executes them directly in the application on your behalf, using the tools it has access to. Say you are booking a local service or trying to organize your inbox (which typically takes multiple steps): the AI model first plans how to achieve the task using its existing knowledge and then interacts with your inbox to execute the task. The agent will continue until it is confident the task has been successfully completed.
0:15

Alright, now that we know *what* an agent is, how does it actually work? When you ask for help on a task, the agent plans a series of steps and executes them directly in the application on your behalf, using the tools it has access to. Say you are booking a local service or trying to organize your inbox (which typically takes multiple steps): the AI model first plans how to achieve the task using its existing knowledge and then interacts with your inbox to execute the task. The agent will continue until it is confident the task has been successfully completed.

Google AI

22,487 次观看 • 11 个月前

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

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 ↓

Argona

38,189 次观看 • 2 个月前

AN ENGINEER SOLVED A PROBLEM NOBODY IN THE COMPANY COULD FULLY MAP ON THEIR OWN The problem wasn't a missing tool, it was that every process touched three other processes nobody had written down. He wired dozens of agents into one shared graph instead of documenting each department's workflow by hand. Each agent owned one process, reading its own logs while writing every dependency it found straight into the shared structure. Within days, the graph surfaced a connection between two departments that had been quietly blocking each other for over a year. The company adopted the graph as its live map of operations, and it hasn't stopped finding new connections since. See what the graph found in the first 48 hours below👇
0:14

AN ENGINEER SOLVED A PROBLEM NOBODY IN THE COMPANY COULD FULLY MAP ON THEIR OWN The problem wasn't a missing tool, it was that every process touched three other processes nobody had written down. He wired dozens of agents into one shared graph instead of documenting each department's workflow by hand. Each agent owned one process, reading its own logs while writing every dependency it found straight into the shared structure. Within days, the graph surfaced a connection between two departments that had been quietly blocking each other for over a year. The company adopted the graph as its live map of operations, and it hasn't stopped finding new connections since. See what the graph found in the first 48 hours below👇

wast3

16,489 次观看 • 2 个月前

Self-improving agents are here. 🧙‍♂️ Every agent run creates a skill.md with reusable learnings. The next agent uses it to do the same task faster, cheaper, and more reliably. Watch the second agent crush it:
0:16

Self-improving agents are here. 🧙‍♂️ Every agent run creates a skill.md with reusable learnings. The next agent uses it to do the same task faster, cheaper, and more reliably. Watch the second agent crush it:

Browser Use

56,242 次观看 • 7 个月前

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

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 ↓

Argona

157,688 次观看 • 3 个月前

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.
0:11

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.

rvaniaaa

27,465 次观看 • 2 个月前

i don't f*cking understand why this isn't popular yet someone has created a memory system that uses 90% fewer tokens while still finding all the expected symbols it builds a local graph of source symbols and their relationships. architecture, decisions and handoffs live as Git-tracked Markdown. a note can point to the code behind it, so a code change can flag that knowledge for review the loop: scan the repo → map the code → write the why → anchor notes to symbols → retrieve a task-sized slice → review drift → commit to Git → continue in the next session in the author's small, one-repo test, graph retrieval returned 10.74× less context than grep top-3 while finding every expected symbol across six tasks the useful part is the connection between memory and evidence. the repo carries what the agent learned, and the code gives you a way to check whether that knowledge still holds save this, then build a second brain for your company⭣
0:15

i don't f*cking understand why this isn't popular yet someone has created a memory system that uses 90% fewer tokens while still finding all the expected symbols it builds a local graph of source symbols and their relationships. architecture, decisions and handoffs live as Git-tracked Markdown. a note can point to the code behind it, so a code change can flag that knowledge for review the loop: scan the repo → map the code → write the why → anchor notes to symbols → retrieve a task-sized slice → review drift → commit to Git → continue in the next session in the author's small, one-repo test, graph retrieval returned 10.74× less context than grep top-3 while finding every expected symbol across six tasks the useful part is the connection between memory and evidence. the repo carries what the agent learned, and the code gives you a way to check whether that knowledge still holds save this, then build a second brain for your company⭣

beamnxw ./

33,354 次观看 • 27 天前

someone just open-sourced the entire "loop engineering" playbook. for free. 8.6k stars on github for loop engineering not prompts. loops. everything you need to build autonomous AI systems: → scheduling → memory & state → planning → sub-agents → verification → worktrees → MCP → stop conditions → safety guardrails → observability → cost tracking notice something? none of these are prompts. they're the systems wrapped around the model. that's where AI engineering is heading. we're moving from: Prompt Engineering → Context Engineering → Harness Engineering → Loop Engineering soon you'll hear people talking about Graph Engineering too. because once one loop works... the next challenge is coordinating hundreds of them. that's exactly what I explain in: save this. I think "loop engineering" is about to become one of the most important concepts in AI.
0:19

someone just open-sourced the entire "loop engineering" playbook. for free. 8.6k stars on github for loop engineering not prompts. loops. everything you need to build autonomous AI systems: → scheduling → memory & state → planning → sub-agents → verification → worktrees → MCP → stop conditions → safety guardrails → observability → cost tracking notice something? none of these are prompts. they're the systems wrapped around the model. that's where AI engineering is heading. we're moving from: Prompt Engineering → Context Engineering → Harness Engineering → Loop Engineering soon you'll hear people talking about Graph Engineering too. because once one loop works... the next challenge is coordinating hundreds of them. that's exactly what I explain in: save this. I think "loop engineering" is about to become one of the most important concepts in AI.

Rahul

65,527 次观看 • 3 个月前

This is pure f*cking treasure. ex-Google engineer reveals his AI agent playbook. 14+ years at Google. $0 to read it. the topic is harness engineering: everything around the model that lets it execute, check its work and recover when something breaks. one example in his breakdown deserves attention. LangChain’s coding agent went from 52.8% to 66.5% on Terminal-Bench 2.0. the model stayed the same. the team changed the prompts, tools and machinery around it. Agent = Model + Harness. the system has six practical jobs: > guides give the agent project rules, constraints and examples > sensors check its work through tests, linters and validators > the loop handles execution, verification, retries and escalation > memory preserves state, artifacts and decisions > permissions control which tools and actions are allowed > observability records tool calls, costs and failures the part worth stealing is what happens after a mistake. an agent keeps declaring broken code finished. you add a verification step before completion. it keeps ignoring a project convention. you add a targeted instruction and a check for that specific failure. it touches files outside its task. you tighten its write permissions. each recurring failure gives you a concrete improvement to make in the harness. that improvement can carry into every future run. this is where the engineering work compounds. bookmark it. start with the mistake you have already paid your agent to make twice.
0:18

This is pure f*cking treasure. ex-Google engineer reveals his AI agent playbook. 14+ years at Google. $0 to read it. the topic is harness engineering: everything around the model that lets it execute, check its work and recover when something breaks. one example in his breakdown deserves attention. LangChain’s coding agent went from 52.8% to 66.5% on Terminal-Bench 2.0. the model stayed the same. the team changed the prompts, tools and machinery around it. Agent = Model + Harness. the system has six practical jobs: > guides give the agent project rules, constraints and examples > sensors check its work through tests, linters and validators > the loop handles execution, verification, retries and escalation > memory preserves state, artifacts and decisions > permissions control which tools and actions are allowed > observability records tool calls, costs and failures the part worth stealing is what happens after a mistake. an agent keeps declaring broken code finished. you add a verification step before completion. it keeps ignoring a project convention. you add a targeted instruction and a check for that specific failure. it touches files outside its task. you tighten its write permissions. each recurring failure gives you a concrete improvement to make in the harness. that improvement can carry into every future run. this is where the engineering work compounds. bookmark it. start with the mistake you have already paid your agent to make twice.

NO1ennn

29,017 次观看 • 1 个月前

this is pure f*cking treasure 20 skills for AI agents with 1.99M+ combined stars an agent is not a model. it is a model plus everything you bolt onto it. these are the bolts. five clusters, twenty repos, all open source, all free. ORCHESTRATION · many agents, one plan : > hermes-agent · 247k > AutoGPT · 187k · > MetaGPT · 70k · > autogen · 61k · > crewAI · 59k · RUNTIME / GRAPH · the loop underneath : > langchain · 147k · > deer-flow · 83k · > langgraph · 42k · > deepagents · 30k · > openai-agents-python · 25k · WEB / BROWSER · reach the open internet : > firecrawl · 181k · > browser-use · 115k · > gemini-cli · 107k · MEMORY / RAG · what it keeps between runs : > ragflow · 91k · > mem0 · 66k · > llama_index · 50k · SHIP IT · turn it into a product : > n8n · 188k · > dify · 140k · > TradingAgents · 107k · > adk-python · 22k · most people pick one framework and stop there. that is the mistake. the stack is orchestration on top, a graph runtime under it, browser and memory on the sides, and one deploy layer that makes it a product instead of a demo. every layer above is already written. you are assembling, not inventing. the gap is one weekend wide.
0:14

this is pure f*cking treasure 20 skills for AI agents with 1.99M+ combined stars an agent is not a model. it is a model plus everything you bolt onto it. these are the bolts. five clusters, twenty repos, all open source, all free. ORCHESTRATION · many agents, one plan : > hermes-agent · 247k > AutoGPT · 187k · > MetaGPT · 70k · > autogen · 61k · > crewAI · 59k · RUNTIME / GRAPH · the loop underneath : > langchain · 147k · > deer-flow · 83k · > langgraph · 42k · > deepagents · 30k · > openai-agents-python · 25k · WEB / BROWSER · reach the open internet : > firecrawl · 181k · > browser-use · 115k · > gemini-cli · 107k · MEMORY / RAG · what it keeps between runs : > ragflow · 91k · > mem0 · 66k · > llama_index · 50k · SHIP IT · turn it into a product : > n8n · 188k · > dify · 140k · > TradingAgents · 107k · > adk-python · 22k · most people pick one framework and stop there. that is the mistake. the stack is orchestration on top, a graph runtime under it, browser and memory on the sides, and one deploy layer that makes it a product instead of a demo. every layer above is already written. you are assembling, not inventing. the gap is one weekend wide.

NO1ennn

21,527 次观看 • 1 个月前

holy sh*t. Jev's founder Diogo Almeida dropped a Google Doc on coding agents one of these PDFs has the map everyone needs: where Jev sits in an agent loop ↓ agents do the work, Jev makes the calls, the LLM only writes: 1 → task in: one Noul before anything runs. in scope, or does a human need to see it first? 2 → dispatch: a Choice picks who takes the step (research, write or review). act at 0.85+, everything below goes to review 3 → act: Jev gates the tool call (allow, confirm or block). the LLM only writes the arguments 4 → check: a Score decides what comes back (drop, summary or keep). whatever Jev is unsure of goes to a human 5 → finish: Jev says done above 0.8, then code proves the file actually exists the LLM shows up in 2 of 5 stages. everything else is a typed answer, plain code or a person. don't refactor your agent. hand Jev the one fork it hits most (usually the tool gate or dispatch) and watch 3 numbers for a week: cost per completed task, time per completed task, and how often escalation fired and whether it was right. if escalation never fires, the threshold is too loose and your agent is quietly running unsupervised.
0:18

holy sh*t. Jev's founder Diogo Almeida dropped a Google Doc on coding agents one of these PDFs has the map everyone needs: where Jev sits in an agent loop ↓ agents do the work, Jev makes the calls, the LLM only writes: 1 → task in: one Noul before anything runs. in scope, or does a human need to see it first? 2 → dispatch: a Choice picks who takes the step (research, write or review). act at 0.85+, everything below goes to review 3 → act: Jev gates the tool call (allow, confirm or block). the LLM only writes the arguments 4 → check: a Score decides what comes back (drop, summary or keep). whatever Jev is unsure of goes to a human 5 → finish: Jev says done above 0.8, then code proves the file actually exists the LLM shows up in 2 of 5 stages. everything else is a typed answer, plain code or a person. don't refactor your agent. hand Jev the one fork it hits most (usually the tool gate or dispatch) and watch 3 numbers for a week: cost per completed task, time per completed task, and how often escalation fired and whether it was right. if escalation never fires, the threshold is too loose and your agent is quietly running unsupervised.

Archive

33,524 次观看 • 28 天前

whoever leaked this has bigger balls than sense Google Research and MIT ran the same agent jobs 260 different ways for Nature last month: they held the prompts, the tools and the compute budget identical and moved nothing but the wiring between the agents, and the same work swung from 70% worse than a single agent to 80.8% better, averaging out at 0.0% i ran my own single agent against the task list first and it cleared 6 of 10 alone, already past the line where a crew starts subtracting this is Graph Engineering, the layer that decides whether a crew is worth 80% more or 70% less, and it installs into the agent you already pay for: - score your solo agent on the real task first: above roughly 45% success that study predicts zero to negative returns from any crew you put around it - under that line, put one supervisor over the fan out: crews with no correction step amplified their own errors to 17.2x the single agent rate, supervised aggregation held it to 4.4x - give every worker one output and let none of them read a peer's draft, so a wrong step reaches the supervisor instead of four other agents - run the comparison again after every model upgrade, because a better model raises your baseline and a higher baseline is what makes a crew stop paying - keep the single agent alive as the control, the only number that says the wiring is earning its calls turns out the shape does not travel: the biggest win came off a finance task under one supervisor and the worst collapse off a planning task with independent agents my position, and it is the arguable one: a crew is a bet on your own diagram, and the model you pick moves that bet less than one arrow does bookmark this, the three moves that draw those arrows before you pay for one extra call are in the post below ↓
0:15

whoever leaked this has bigger balls than sense Google Research and MIT ran the same agent jobs 260 different ways for Nature last month: they held the prompts, the tools and the compute budget identical and moved nothing but the wiring between the agents, and the same work swung from 70% worse than a single agent to 80.8% better, averaging out at 0.0% i ran my own single agent against the task list first and it cleared 6 of 10 alone, already past the line where a crew starts subtracting this is Graph Engineering, the layer that decides whether a crew is worth 80% more or 70% less, and it installs into the agent you already pay for: - score your solo agent on the real task first: above roughly 45% success that study predicts zero to negative returns from any crew you put around it - under that line, put one supervisor over the fan out: crews with no correction step amplified their own errors to 17.2x the single agent rate, supervised aggregation held it to 4.4x - give every worker one output and let none of them read a peer's draft, so a wrong step reaches the supervisor instead of four other agents - run the comparison again after every model upgrade, because a better model raises your baseline and a higher baseline is what makes a crew stop paying - keep the single agent alive as the control, the only number that says the wiring is earning its calls turns out the shape does not travel: the biggest win came off a finance task under one supervisor and the worst collapse off a planning task with independent agents my position, and it is the arguable one: a crew is a bet on your own diagram, and the model you pick moves that bet less than one arrow does bookmark this, the three moves that draw those arrows before you pay for one extra call are in the post below ↓

Argona

892,436 次观看 • 2 个月前

A public chain doesn’t just show amounts. It shows relationships. Who paid whom. How often. What size? What came next? That’s a graph, not a receipt. A shielded account on the wallet you already use hides that graph by default. ZK proves the tx is valid. Disclosure only when it actually has to be proven. How it works → Powered by Palliora
0:13

A public chain doesn’t just show amounts. It shows relationships. Who paid whom. How often. What size? What came next? That’s a graph, not a receipt. A shielded account on the wallet you already use hides that graph by default. ZK proves the tx is valid. Disclosure only when it actually has to be proven. How it works → Powered by Palliora

Veilnyx

99,014 次观看 • 1 个月前