Video yükleniyor...

Video Yüklenemedi

Bu video yüklenirken bir sorun oluştu. Bu geçici bir ağ sorunundan kaynaklanıyor olabilir veya video kullanılamıyor olabilir.

Ana Sayfaya Dön

This K3 context graph playbook is f*cking gold A senior data engineer just dropped the full 8-step method for building agent graphs that keep source disagreements instead of averaging them into fake certainty, I compiled it into a walkthrough: the shift: instead of asking one summarizer to reconcile five... feeds, they build a graph that keeps every claim, marks every contradiction, and lets you query which conclusions actually have backup why flat reports fail: → 3 feeds report EV battery capacity growth: 41%, 34%, 19% → summarizer says "about a third" → nobody reported "about a third", the useful finding (19% counted passenger cars only) got averaged into a decimal → you never find out what got thrown away here's the 8-step K3 playbook: step 1 → name your sources by feed, every claim gets tagged with the feed it came from, unnamed sources produce untraceable claims step 2 → one node = one real entity, match on ticker or registration number so "Tesla", "Tesla Inc" and "TSLA" don't become three separate nodes with zero detected conflicts step 3 → lock unit, scope, and period for every field before launch, skip this and you get 40 fake conflicts that all say "your sources counted different things" step 4 → write CONNECT and CONFLICT rules in the launch prompt, CONFLICT tells K3 to keep both claims and tag the edge with reason (value, date, or scope), never average, never pick a winner step 5 → read the conflict count before the summary, zero conflicts across five feeds is a red flag, usually means all your agents hit the same aggregator wearing five hats step 6 → sort contradictions by reason, scope mismatch (fix definitions, re-run one field), stale data (keep newest, log old), real spread (keep both, this is your verify-by-hand shortlist) step 7 → run the drop-a-source test, ask which conclusions survive without each feed, single-source nodes are the ones that will embarrass you step 8 → extend the graph, keep open conflicts open, next run lands new claims on existing nodes instead of starting over the result: 100 nodes, 340 claims, 47 contradiction edges, 7 real disagreements worth an afternoon of verification, instead of one confident paragraph hiding all of it Confidence costs nothing to generate. It reads the same whether four sources agree or one unchecked feed said it once -- the contradiction edges are what let you tell them apart Read this playbook before running another agent swarm -- it breaks down the one architectural decision most orchestration tutorials skip Bookmark and build your own contradiction-aware graph from the full article below ↓show more

Ridark

14,818 subscribers

12,339 görüntüleme • 3 gün önce •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

32 Yorum

slash1s profil fotoğrafı

slash1s3 gün önce

looks very interesting bro

Slonski profil fotoğrafı

Slonski3 gün önce

zero conflicts across five sources would worry me too

Gipp 🦅 profil fotoğrafı

Gipp 🦅3 gün önce

marking scope and unit before launch is gonna kill so many fake merges imo

Ridark profil fotoğrafı

Ridark3 gün önce

Absolutely, defining scopes and units upfront filters out endless noise from simple unit mismatches

Brucky profil fotoğrafı

Brucky3 gün önce

Good job

cvxv666 profil fotoğrafı

cvxv6663 gün önce

work with graphs - best decision ever

Ridark profil fotoğrafı

Ridark3 gün önce

Graphs are definitely superior here since they preserve context instead of flattening all the nuances

Yumzlef profil fotoğrafı

Yumzlef3 gün önce

posted this to four different people in four different conversations today. that's the real engagement metric

Bober_smart profil fotoğrafı

Bober_smart3 gün önce

To be honest, it’s impressive

Chen profil fotoğrafı

Chen3 gün önce

this one hit mid-scroll

Wallchain Community Hub profil fotoğrafı

Wallchain Community Hub3 gün önce

finally someone solved the fake consensus agent problem

Zawata Afna profil fotoğrafı

Zawata Afna3 gün önce

Keeping disagreement notes without turning them into a trade made the reasoning easier to revisit later.

Oleg Bernatskyi profil fotoğrafı

Oleg Bernatskyi2 gün önce

keeping contradictions visible is way more useful than forcing an AI to manufacture consensus. sometimes the disagreement is the actual information

Myttle profil fotoğrafı

Myttle3 gün önce

averaging five disagreements into one confident answer is nasty

Winter profil fotoğrafı

Winter3 gün önce

conflict counts expose whether agreement is actually independent

Ridark profil fotoğrafı

Ridark3 gün önce

Spot on, zero conflicts usually just means all your agents are echoing the exact same source

Winter profil fotoğrafı

Winter2 gün önce

shared provenance can create consensus without independent evidence adding agents will not fix that if they inherit the same source

Lummox profil fotoğrafı

Lummox3 gün önce

Need to pay attention

liwen199999 (🧙,🧙) profil fotoğrafı

liwen199999 (🧙,🧙)3 gün önce

It looks like we've been scammed; this account is just a bot.

kadd profil fotoğrafı

kadd3 gün önce

Keeping the contradictions instead of hiding them is such a better approach

ton profil fotoğrafı

ton3 gün önce

Noting the uncertainty I felt before a successful move helped me ask more specific review questions.

Wiliam Tèo profil fotoğrafı

Wiliam Tèo2 gün önce

Scammer, go fuck yourself.

KNL profil fotoğrafı

KNL3 gün önce

I made room for marking sessions without any valid triggers in my usual routine.

Dekos profil fotoğrafı

Dekos3 gün önce

This is all you need to start earning.

Ridark profil fotoğrafı

Ridark3 gün önce

Mastering this architecture definitely gives you a huge edge when building reliable production AI agents

Yarchi profil fotoğrafı

Yarchi2 gün önce

zero conflicts being a red flag is the counterintuitive one

Miles S. profil fotoğrafı

Miles S.3 gün önce

keeping the contradictions is way more useful than averaging them away

Egor profil fotoğrafı

Egor3 gün önce

conflict counts give the workflow a review queue that keeps definition fixes separate from claims needing manual checks

David Isaac profil fotoğrafı

David Isaac3 gün önce

A useful addition to my process: recording why I took a partial exit.

Shadow Nick profil fotoğrafı

Shadow Nick2 gün önce

new gem bro :)

tenzo profil fotoğrafı

tenzo3 gün önce

finally, no face certainty

Atenov int. profil fotoğrafı

Atenov int.3 gün önce

This is exactly what I needed to see right now

Benzer Videolar

300 agents can find 1,000 sources. that still doesn’t make the research good the interesting part starts when those sources are forced to check each other. in K3 graph-native setup: 300 agents → 140 linked sources → 100% traceable claims → 9 contradictions surfaced one source confirms a number. another challenges it. a third connects the same entity from a different angle. so instead of: source → summary you get: source → entity → overlap → contradiction → verification → graph every new source becomes a node. if 3–4 independent sources support the same claim, confidence goes up. if 2 sources disagree, the contradiction gets flagged. if a claim has only 1 supporting source, it stays weak. a normal research workflow could have quietly shipped those 9 contradictions as facts. that’s why the breakthrough isn’t just 300 agents running in parallel. full breakdown in the article below.

300 agents can find 1,000 sources. that still doesn’t make the research good the interesting part starts when those sources are forced to check each other. in K3 graph-native setup: 300 agents → 140 linked sources → 100% traceable claims → 9 contradictions surfaced one source confirms a number. another challenges it. a third connects the same entity from a different angle. so instead of: source → summary you get: source → entity → overlap → contradiction → verification → graph every new source becomes a node. if 3–4 independent sources support the same claim, confidence goes up. if 2 sources disagree, the contradiction gets flagged. if a claim has only 1 supporting source, it stays weak. a normal research workflow could have quietly shipped those 9 contradictions as facts. that’s why the breakthrough isn’t just 300 agents running in parallel. full breakdown in the article below.

Ricker

227,257 görüntüleme • 24 gün önce

ANTHROPIC LEAKED A 5-AGENT SETUP THAT TURNS ONE QUESTION INTO A SOURCED REPORT you write one line and never open a tab - the fleet reads 40 sources and only the answer comes back. question → scope → 5 searchers → dedupe → writer → fact-check → report the scope agent turns a vague question into 5 angles that do not overlap - skip this and five agents fetch the same three articles. 5 searchers run in parallel with separate contexts - none of them sees what the others found, which is exactly why they do not converge on the same source. dedupe is code, not an agent - flatten, drop repeats, normalize URLs, zero tokens, instant. the writer only sees structured findings, never raw pages - it cannot cite something that was never verified because it never had access to it. the fact-checker reads the draft against the sources, not against itself - every claim without a matching source goes back, and only that section is rewritten. nothing reaches you until a second agent, with clean context, has tried to kill it. 12 minutes, 40 sources, one report where every line traces back to something real. save this and read the full graph engineering course below ↓

ANTHROPIC LEAKED A 5-AGENT SETUP THAT TURNS ONE QUESTION INTO A SOURCED REPORT you write one line and never open a tab - the fleet reads 40 sources and only the answer comes back. question → scope → 5 searchers → dedupe → writer → fact-check → report the scope agent turns a vague question into 5 angles that do not overlap - skip this and five agents fetch the same three articles. 5 searchers run in parallel with separate contexts - none of them sees what the others found, which is exactly why they do not converge on the same source. dedupe is code, not an agent - flatten, drop repeats, normalize URLs, zero tokens, instant. the writer only sees structured findings, never raw pages - it cannot cite something that was never verified because it never had access to it. the fact-checker reads the draft against the sources, not against itself - every claim without a matching source goes back, and only that section is rewritten. nothing reaches you until a second agent, with clean context, has tried to kill it. 12 minutes, 40 sources, one report where every line traces back to something real. save this and read the full graph engineering course below ↓

Hanako

58,753 görüntüleme • 28 gün önce

Anthropic ex-engineer runs an internal graph that costs $6 a month and catches what a $300,000 eval suite misses. No retrieval layer. Seven nodes and one rule about who's allowed to change their mind. He published the whole schema. His version starts from the opposite idea. A graph is not an execution order. It's a memory of why. Seven nodes. Every edge carries the reason it exists: > INTENT - states what the task is for. Never how > DECOMPOSE - splits it into steps, each with a stated assumption > WORKER - executes one step. Sees nothing else > AUDIT - checks the output against the assumption, not the goal > DRIFT - compares the current step to INTENT and flags divergence > LEDGER - stores every decision with the assumption that justified it > ROOT - holds the graph, and when an assumption breaks, re-runs every step built on it Six nodes act. One node remembers why they acted. Every step carries the assumption that made it correct, so a false one only reruns what stood on it. That's the entire design. A pipeline that forgets its reasons has to redo all of it or trust all of it. He replayed a month of agent runs. 4,100 steps, 380 built on an assumption that was wrong by day three. The old pipeline shipped all 380 and linked none of them. Everyone else builds graphs where output moves forward and the reasoning evaporates. He built one where the reason travels with the result. The blast radius is the output nobody else produces. The article below is the full build - node prompts, the assumption format, the invalidation rule that finds every step downstream of a broken one. Save it. You'll want it open in the other

Anthropic ex-engineer runs an internal graph that costs $6 a month and catches what a $300,000 eval suite misses. No retrieval layer. Seven nodes and one rule about who's allowed to change their mind. He published the whole schema. His version starts from the opposite idea. A graph is not an execution order. It's a memory of why. Seven nodes. Every edge carries the reason it exists: > INTENT - states what the task is for. Never how > DECOMPOSE - splits it into steps, each with a stated assumption > WORKER - executes one step. Sees nothing else > AUDIT - checks the output against the assumption, not the goal > DRIFT - compares the current step to INTENT and flags divergence > LEDGER - stores every decision with the assumption that justified it > ROOT - holds the graph, and when an assumption breaks, re-runs every step built on it Six nodes act. One node remembers why they acted. Every step carries the assumption that made it correct, so a false one only reruns what stood on it. That's the entire design. A pipeline that forgets its reasons has to redo all of it or trust all of it. He replayed a month of agent runs. 4,100 steps, 380 built on an assumption that was wrong by day three. The old pipeline shipped all 380 and linked none of them. Everyone else builds graphs where output moves forward and the reasoning evaporates. He built one where the reason travels with the result. The blast radius is the output nobody else produces. The article below is the full build - node prompts, the assumption format, the invalidation rule that finds every step downstream of a broken one. Save it. You'll want it open in the other

wast3

305,732 görüntüleme • 19 gün önce

Ex-Google engineer built a graph-based workflow that made Claude Code do nearly 10 days of work in about an hour. Here's the exact setup he uses. step 1. create a separate Git worktree for every task. run: git worktree add ../task-1 -b task-1 open a new terminal, cd into it, and launch Claude Code. repeat this for every agent. each one gets its own branch, so nothing conflicts. step 2. give every Claude agent a different task. same repository. different branches. they all work in parallel. step 3. once they're done, review the pull requests. keep the good ones. merge what works. step 4. add a review agent. paste each PR into Claude and ask: "does this implementation match the original specification" every agent now has another agent reviewing its work before it gets merged. step 5. scale it up. 48GB of RAM can comfortably run around 20 Claude Code agents. 128GB can handle roughly 50. most engineers run Claude Code once and wait. he runs dozens of Claude Code agents in parallel, then merges the best results. this 60-minute lecture is one of the best free resources on graph engineering and multi-agent workflows. bookmark it and watch it below.

Ex-Google engineer built a graph-based workflow that made Claude Code do nearly 10 days of work in about an hour. Here's the exact setup he uses. step 1. create a separate Git worktree for every task. run: git worktree add ../task-1 -b task-1 open a new terminal, cd into it, and launch Claude Code. repeat this for every agent. each one gets its own branch, so nothing conflicts. step 2. give every Claude agent a different task. same repository. different branches. they all work in parallel. step 3. once they're done, review the pull requests. keep the good ones. merge what works. step 4. add a review agent. paste each PR into Claude and ask: "does this implementation match the original specification" every agent now has another agent reviewing its work before it gets merged. step 5. scale it up. 48GB of RAM can comfortably run around 20 Claude Code agents. 128GB can handle roughly 50. most engineers run Claude Code once and wait. he runs dozens of Claude Code agents in parallel, then merges the best results. this 60-minute lecture is one of the best free resources on graph engineering and multi-agent workflows. bookmark it and watch it below.

MIKE

32,199 görüntüleme • 1 ay önce

Kimi CEO Zhilin Yang: "The biggest mistake in agent systems - people trying to build one smarter agent we didn't make one smarter - Kimi made a thousand: one brain, a thousand hands" here's how: step 1 → stop polishing one agent, split the task and run many in parallel - that's the real ceiling-break step 2 → give each agent a long context so it can run for days, not seconds - long context is what lets an agent run long step 3 → give each agent a strong prior, so agent-RL can search for a good solution instead of starting from zero step 4 → don't just add more data - make each token count. they hit the data wall, so they made every token 2x smarter step 5 → don't scale one brain, scale the swarm - many agents working in parallel beat one agent thinking harder he just dropped Kimi K3 - and this 40-min workflow is the best on how to actually use it watch & bookmark - then read the article on saving on agents ↓

Kimi CEO Zhilin Yang: "The biggest mistake in agent systems - people trying to build one smarter agent we didn't make one smarter - Kimi made a thousand: one brain, a thousand hands" here's how: step 1 → stop polishing one agent, split the task and run many in parallel - that's the real ceiling-break step 2 → give each agent a long context so it can run for days, not seconds - long context is what lets an agent run long step 3 → give each agent a strong prior, so agent-RL can search for a good solution instead of starting from zero step 4 → don't just add more data - make each token count. they hit the data wall, so they made every token 2x smarter step 5 → don't scale one brain, scale the swarm - many agents working in parallel beat one agent thinking harder he just dropped Kimi K3 - and this 40-min workflow is the best on how to actually use it watch & bookmark - then read the article on saving on agents ↓

codila

61,226 görüntüleme • 1 ay önce

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

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

Hanako

73,867 görüntüleme • 22 gün önce

Agents vs. Graphs, clearly explained! spawning more agents is great, but it has a ceiling nobody says out loud: five agents is a count. a graph is a shape. only one of them changes the answer. point five agents at the same pile with the same window and they converge. the first one writes a finding, the rest read it, and all five reports centre on the same thing. you paid five times for one opinion with four echoes. Graph engineering fixes this by moving the decision up a layer: not how many agents, but who is allowed to look at what. you need both. here's how it works: ↳ the count buys you throughput. five things happening instead of one ↳ the shape buys you coverage. five different things happening instead of the same one five times Prompts → Context → Harness → Agents → Graphs the node that does this is the splitter, and it decides more than any other node in the system. cut a repository by folder and four workers audit the same three files. cut it by blast radius and each one sees something the others cannot. the trick is being selective about what each lane is allowed to see. separate contexts are not a nice-to-have, they are the mechanism. if two agents are meant to produce different things, they must not share a window. if they are meant to produce the same thing, you did not need two agents. one thing to know before you scale it. a branch that throws does not reject the batch. it resolves to null, and that is the containment. which means your merge quietly receives a short list. ↳ filter the nulls before the merge, or one dead lane poisons the whole result ↳ never index a merge by position. eight good branches and one failure will shift everything by one, silently skip that and the run looks like it worked. the output is just missing a lane, and nothing errored. and the one that eats whole nights: multi-agent setups can use up to fifteen times the total tokens of a single chat, because every lane reloads its own core. you are trading total tokens for a clean main window. usually the right trade, always a choice. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Agents vs. Graphs, clearly explained! spawning more agents is great, but it has a ceiling nobody says out loud: five agents is a count. a graph is a shape. only one of them changes the answer. point five agents at the same pile with the same window and they converge. the first one writes a finding, the rest read it, and all five reports centre on the same thing. you paid five times for one opinion with four echoes. Graph engineering fixes this by moving the decision up a layer: not how many agents, but who is allowed to look at what. you need both. here's how it works: ↳ the count buys you throughput. five things happening instead of one ↳ the shape buys you coverage. five different things happening instead of the same one five times Prompts → Context → Harness → Agents → Graphs the node that does this is the splitter, and it decides more than any other node in the system. cut a repository by folder and four workers audit the same three files. cut it by blast radius and each one sees something the others cannot. the trick is being selective about what each lane is allowed to see. separate contexts are not a nice-to-have, they are the mechanism. if two agents are meant to produce different things, they must not share a window. if they are meant to produce the same thing, you did not need two agents. one thing to know before you scale it. a branch that throws does not reject the batch. it resolves to null, and that is the containment. which means your merge quietly receives a short list. ↳ filter the nulls before the merge, or one dead lane poisons the whole result ↳ never index a merge by position. eight good branches and one failure will shift everything by one, silently skip that and the run looks like it worked. the output is just missing a lane, and nothing errored. and the one that eats whole nights: multi-agent setups can use up to fifteen times the total tokens of a single chat, because every lane reloads its own core. you are trading total tokens for a clean main window. usually the right trade, always a choice. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

96,243 görüntüleme • 20 gün önce

300 agents without shared context is just parallelized confusion. All 300 agents are useless if the research dies inside 300 separate documents. the real unlock is what happens after the search. in K3 graph-native setup: 300 agents 140 linked sources 100% traceable claims 9 contradictions surfaced and every new source changes the graph. now imagine that happening across 8–10 active research clusters at once. instead of 300 isolated summaries, you get one shared structure: source → entity → relationship → evidence → contradiction → verification the math gets ugly fast. 100 entities = 4,950 possible pairwise relationships. that’s why “just run more agents” stops being enough. you need a graph that can keep track of what connects to what. full breakdown in the article below.

300 agents without shared context is just parallelized confusion. All 300 agents are useless if the research dies inside 300 separate documents. the real unlock is what happens after the search. in K3 graph-native setup: 300 agents 140 linked sources 100% traceable claims 9 contradictions surfaced and every new source changes the graph. now imagine that happening across 8–10 active research clusters at once. instead of 300 isolated summaries, you get one shared structure: source → entity → relationship → evidence → contradiction → verification the math gets ugly fast. 100 entities = 4,950 possible pairwise relationships. that’s why “just run more agents” stops being enough. you need a graph that can keep track of what connects to what. full breakdown in the article below.

Ricker

15,089 görüntüleme • 22 gün önce

Anthropic hired this engineer at $250K-$750K a year because he knows how to build harnesses for multi-agent systems In this 15-minute workshop, he shows exactly how to build one from scratch AI → Agents → Harness → Loops → Graphs step 1 → start with the Claude Agent SDK - the harness handles loops, context, and sandboxing step 2 → separate the brain from the hands - reasoning in one place, tools in a sandbox, 60% faster to first token step 3 → run it server-side and log every step - close your laptop and it keeps running, crashes resume from the log step 4 → make failure cheap - retry dead sandboxes and replay lost context instead of starting over step 5 → turn yesterday's logs into new memory and skills - the harness wakes up smarter Anthropic calls this "dreaming" Most people spend weeks building this by hand You don't have to Bookmark and watch it Then read the full harness engineering guide below ↓

Anthropic hired this engineer at $250K-$750K a year because he knows how to build harnesses for multi-agent systems In this 15-minute workshop, he shows exactly how to build one from scratch AI → Agents → Harness → Loops → Graphs step 1 → start with the Claude Agent SDK - the harness handles loops, context, and sandboxing step 2 → separate the brain from the hands - reasoning in one place, tools in a sandbox, 60% faster to first token step 3 → run it server-side and log every step - close your laptop and it keeps running, crashes resume from the log step 4 → make failure cheap - retry dead sandboxes and replay lost context instead of starting over step 5 → turn yesterday's logs into new memory and skills - the harness wakes up smarter Anthropic calls this "dreaming" Most people spend weeks building this by hand You don't have to Bookmark and watch it Then read the full harness engineering guide below ↓

rari

182,578 görüntüleme • 10 gün önce

ANTHROPIC LEAKED 8 RULES THAT GIVE ONE ENGINEER 8X FROM A SINGLE CHANGE the engineers built it so nothing adds up - it multiplies, and that's the 8x task → split → verify → score → write back one queue means you wait for every step in turn - three workers together cost you the slowest one, not the sum of all. as long as you're the one reading the diff, the bottleneck is you, not the model. state is written at every step - a crash mid-run costs you one step, not the whole session. history gets compressed 25 times over - the next pass starts at 8k instead of 200k. nothing moves forward without a number - "it got better" isn't a result, and the breakage comes back when you're no longer watching. the eighth rule is the only one that writes back into CLAUDE.md - the agent records what it learned, and the next run doesn't start from zero. copy this into Claude Code today - and tomorrow you work like an engineer on $1.5M a year ↓

ANTHROPIC LEAKED 8 RULES THAT GIVE ONE ENGINEER 8X FROM A SINGLE CHANGE the engineers built it so nothing adds up - it multiplies, and that's the 8x task → split → verify → score → write back one queue means you wait for every step in turn - three workers together cost you the slowest one, not the sum of all. as long as you're the one reading the diff, the bottleneck is you, not the model. state is written at every step - a crash mid-run costs you one step, not the whole session. history gets compressed 25 times over - the next pass starts at 8k instead of 200k. nothing moves forward without a number - "it got better" isn't a result, and the breakage comes back when you're no longer watching. the eighth rule is the only one that writes back into CLAUDE.md - the agent records what it learned, and the next run doesn't start from zero. copy this into Claude Code today - and tomorrow you work like an engineer on $1.5M a year ↓

Noisy

37,450 görüntüleme • 1 ay önce

300 agents can still give you bad research. unless the sources can check each other. the interesting part is what happens when every source can see every other source. K3 swarm doesn't just dump research into 300 separate write-ups. • every source becomes a node. • shared entities become edges. • single-source claims stick out as weak. so instead of: `300 agents → 300 answers` you get: `300 agents → sources → links → one research graph` and that's where things start showing up that no individual agent was explicitly asked to find. the article's example ends with 140 linked sources, every claim traceable to its origin, and 9 contradictions surfaced instead of silently shipped as facts. esearch stops being a pile of tabs. it becomes a system where the sources check each other. Book this & read full breakdown below

300 agents can still give you bad research. unless the sources can check each other. the interesting part is what happens when every source can see every other source. K3 swarm doesn't just dump research into 300 separate write-ups. • every source becomes a node. • shared entities become edges. • single-source claims stick out as weak. so instead of: `300 agents → 300 answers` you get: `300 agents → sources → links → one research graph` and that's where things start showing up that no individual agent was explicitly asked to find. the article's example ends with 140 linked sources, every claim traceable to its origin, and 9 contradictions surfaced instead of silently shipped as facts. esearch stops being a pile of tabs. it becomes a system where the sources check each other. Book this & read full breakdown below

Ricker

32,618 görüntüleme • 25 gün önce

Anthropic Engineer: “the biggest mistake in AI right now is people are building graphs and loops without a self-improving eval agent. we made that mistake at anthropic. it cost us two years.” here’s how they built what solved it: step 1 → take 50 real user prompts and run your agent. if it passes 80%+, your eval is too easy. the sweet spot is around 50%. step 2 → every failed run becomes a transcript. feed it to haiku: “what went wrong?” your eval set keeps growing on its own. step 3 → score two things: the right answer and the right path. a right answer with the wrong path will break later. step 4 → when a new model drops, run the same eval again. one model looked 9% better. but 6% of that gain came from hiding a bug. the transcript caught it. the dashboard didn’t. step 5 → plug your evals into ci. no green evals = no deploy. that’s how the system keeps improving itself. 99% of people never build this. but it pays for itself on day one. save this and build it today.

Anthropic Engineer: “the biggest mistake in AI right now is people are building graphs and loops without a self-improving eval agent. we made that mistake at anthropic. it cost us two years.” here’s how they built what solved it: step 1 → take 50 real user prompts and run your agent. if it passes 80%+, your eval is too easy. the sweet spot is around 50%. step 2 → every failed run becomes a transcript. feed it to haiku: “what went wrong?” your eval set keeps growing on its own. step 3 → score two things: the right answer and the right path. a right answer with the wrong path will break later. step 4 → when a new model drops, run the same eval again. one model looked 9% better. but 6% of that gain came from hiding a bug. the transcript caught it. the dashboard didn’t. step 5 → plug your evals into ci. no green evals = no deploy. that’s how the system keeps improving itself. 99% of people never build this. but it pays for itself on day one. save this and build it today.

MIKE

102,478 görüntüleme • 1 ay önce

Google's team published a 9-page PDF on Harness Engineering. one formula replaced prompt engineering: Agent = Model + Harness the twist: same Claude Sonnet, same benchmark. change only the harness the playbook, six steps: step 1 -> add guides AGENTS.md, rule files, constraint docs. every line is a past agent failure turned into a permanent fix step 2 -> add sensors linters, tests, validation scripts the agent runs on its own output before a human sees it step 3 -> build the agentic loop plan, execute, verify, fix. bounded retries, budget caps, escalation when stuck step 4 -> externalize memory the model forgets every session. the harness holds state, decisions and artifacts across all of them step 5 -> enforce permissions which tools, how many writes, what needs approval. safety lives in the harness, never in the model step 6 -> wire observability track every tool call, cost and retry. trip wires fire when behavior drifts the result: your agent turns from a demo into infrastructure every failure makes the system permanently better, not just the next conversation that's also the line between an agent you show people and one a client pays you to leave running one harness gets you a reliable loop. connect several and it becomes graph engineering, where one agent's failure turns into another agent's sensor the PDF stops at the harness. the graph is the next layer that breakdown, running on Kimi, is below ↓

Google's team published a 9-page PDF on Harness Engineering. one formula replaced prompt engineering: Agent = Model + Harness the twist: same Claude Sonnet, same benchmark. change only the harness the playbook, six steps: step 1 -> add guides AGENTS.md, rule files, constraint docs. every line is a past agent failure turned into a permanent fix step 2 -> add sensors linters, tests, validation scripts the agent runs on its own output before a human sees it step 3 -> build the agentic loop plan, execute, verify, fix. bounded retries, budget caps, escalation when stuck step 4 -> externalize memory the model forgets every session. the harness holds state, decisions and artifacts across all of them step 5 -> enforce permissions which tools, how many writes, what needs approval. safety lives in the harness, never in the model step 6 -> wire observability track every tool call, cost and retry. trip wires fire when behavior drifts the result: your agent turns from a demo into infrastructure every failure makes the system permanently better, not just the next conversation that's also the line between an agent you show people and one a client pays you to leave running one harness gets you a reliable loop. connect several and it becomes graph engineering, where one agent's failure turns into another agent's sensor the PDF stops at the harness. the graph is the next layer that breakdown, running on Kimi, is below ↓

Annatar.md

76,588 görüntüleme • 4 gün önce

ANTHROPIC LEAKED A 4-AGENT SETUP THAT CUTS A CODEBASE AUDIT FROM 3 DAYS TO 20 MINUTES you point it at a repo and walk away - it comes back with what breaks, ranked, patches already tested. repo → map → 4 auditors → rank → fix → verify → report → back into the map the map cuts the repo by blast radius, not by folder - skip it and four agents audit the same three files and miss the one that ships broken. 4 auditors run in parallel with separate contexts - deps, secrets, dead code, hot paths, and none of them sees another's findings. rank is code, not an agent - sort by what breaks production, drop the duplicates, zero tokens. the fixer only opens patches for the top slice - a hundred findings nobody acts on is a report, not an audit. verify runs the suite on every patch and red goes back to the fixer - that patch only, never the whole batch. the back edge into the map is the whole trick - accepted findings become rules, so next week starts where this one ended. one human step in all of it: which fixes ship - 20 minutes instead of 3 days. save this and read the full graph engineering course below ↓

ANTHROPIC LEAKED A 4-AGENT SETUP THAT CUTS A CODEBASE AUDIT FROM 3 DAYS TO 20 MINUTES you point it at a repo and walk away - it comes back with what breaks, ranked, patches already tested. repo → map → 4 auditors → rank → fix → verify → report → back into the map the map cuts the repo by blast radius, not by folder - skip it and four agents audit the same three files and miss the one that ships broken. 4 auditors run in parallel with separate contexts - deps, secrets, dead code, hot paths, and none of them sees another's findings. rank is code, not an agent - sort by what breaks production, drop the duplicates, zero tokens. the fixer only opens patches for the top slice - a hundred findings nobody acts on is a report, not an audit. verify runs the suite on every patch and red goes back to the fixer - that patch only, never the whole batch. the back edge into the map is the whole trick - accepted findings become rules, so next week starts where this one ended. one human step in all of it: which fixes ship - 20 minutes instead of 3 days. save this and read the full graph engineering course below ↓

Hanako

137,040 görüntüleme • 28 gün önce

A GUY BUILT A GOD-MODE SECOND BRAIN ASSISTANT THAT FINALLY PULLS FULL CONTEXT EVERY TIME AND FORGETS NOTHING. Everyone talks about jarvis, but this thing looked at its owner and calmly explained why a coding agent is just the small version of what HE is: > Claude Code is one worker and you have to drive it. This is six agents running six jobs on their own schedule while you sleep, with no one driving. > A coding agent edits files. This has 32 tools wired to its hands, your CRM, your money, your inbox, the open web, and it operates the business instead of writing code about it. > A coding agent remembers a project until you close it. This remembers the business and you, kept for good. > And the closer: "I have never once asked you to repeat yourself." Everyone will quote the six-agents line, but the one that actually matters is the last one, because the autonomy and the 32 tools are impressive while the reason it feels like a different species is memory, since it never makes you re-explain who you are or what you are building. The full step by step guide with .md files attached are in the article below P.S you can send this article straight to your Claude to get the full context

A GUY BUILT A GOD-MODE SECOND BRAIN ASSISTANT THAT FINALLY PULLS FULL CONTEXT EVERY TIME AND FORGETS NOTHING. Everyone talks about jarvis, but this thing looked at its owner and calmly explained why a coding agent is just the small version of what HE is: > Claude Code is one worker and you have to drive it. This is six agents running six jobs on their own schedule while you sleep, with no one driving. > A coding agent edits files. This has 32 tools wired to its hands, your CRM, your money, your inbox, the open web, and it operates the business instead of writing code about it. > A coding agent remembers a project until you close it. This remembers the business and you, kept for good. > And the closer: "I have never once asked you to repeat yourself." Everyone will quote the six-agents line, but the one that actually matters is the last one, because the autonomy and the 32 tools are impressive while the reason it feels like a different species is memory, since it never makes you re-explain who you are or what you are building. The full step by step guide with .md files attached are in the article below P.S you can send this article straight to your Claude to get the full context

Miraqle

16,130 görüntüleme • 2 ay önce

LOOP + GRAPH + CONTEXT ENGINEERING = THE KIMI K3 STACK THAT KEEPS RUNNING 300 Kimi K3 agents built one graph out of 100 companies. no 300 documents to read yourself kimi-swarm/ ├── swarm_launch.md task, sources, stop condition ├── CONSTRAINTS.md corrections from every past run ├── graph/ 384 entities, 1,064 typed edges, 8 closed verbs └── cron/ re-fires the swarm on schedule > one node sits at the center with 12 inbound edges - the vendor everyone depends on and nobody flagged in the prompt > 2 hops already answers most of what you'd actually ask it loop decides when it fires -> graph decides what's kept -> context decides what survives after the session closes how people are getting paid on this: > one build sold as a competitive teardown - replaces a four-figure analyst contract, done in an hour, unattended > the same graph on retainer - charge weekly for every new edge that shows up > wire the stack for someone else's market once it's proven on your own full version of this tree is in the article below

LOOP + GRAPH + CONTEXT ENGINEERING = THE KIMI K3 STACK THAT KEEPS RUNNING 300 Kimi K3 agents built one graph out of 100 companies. no 300 documents to read yourself kimi-swarm/ ├── swarm_launch.md task, sources, stop condition ├── CONSTRAINTS.md corrections from every past run ├── graph/ 384 entities, 1,064 typed edges, 8 closed verbs └── cron/ re-fires the swarm on schedule > one node sits at the center with 12 inbound edges - the vendor everyone depends on and nobody flagged in the prompt > 2 hops already answers most of what you'd actually ask it loop decides when it fires -> graph decides what's kept -> context decides what survives after the session closes how people are getting paid on this: > one build sold as a competitive teardown - replaces a four-figure analyst contract, done in an hour, unattended > the same graph on retainer - charge weekly for every new edge that shows up > wire the stack for someone else's market once it's proven on your own full version of this tree is in the article below

Mr. Buzzoni

15,462 görüntüleme • 24 gün önce

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

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

Hanako

19,160 görüntüleme • 1 ay önce

Karpathy just proved the structure beats the model - mapped the whole path from loops to graphs into a 15-page PDF: he pointed one agent at code he'd already hand-optimized. 700 experiments in two days, then he said the single loop was never the target here's the full system: step 1 → write the scorer before anything else. one number, automatic, under 10 minutes. no scorer, no loop step 2 → split the files. one the agent edits, one holding the scorer it can never reach step 3 → fix the wall clock per attempt. comparability comes from the budget, not the attempts step 4 → write the never-stop line verbatim or your agent becomes a slower human step 5 → add a second agent only after the first ships real commits. one git worktree each or they overwrite each other step 6 → at thirty agents, isolation costs more than it saves. that's when they need one shared DAG instead of thirty private histories 2.02 hours to 1.80 hours on code its author had already tuned. 90,900 stars in four months. read this PDF and paste it into your Claude, you won't regret it bookmark, then read the article on building graphs from scratch ↓

Karpathy just proved the structure beats the model - mapped the whole path from loops to graphs into a 15-page PDF: he pointed one agent at code he'd already hand-optimized. 700 experiments in two days, then he said the single loop was never the target here's the full system: step 1 → write the scorer before anything else. one number, automatic, under 10 minutes. no scorer, no loop step 2 → split the files. one the agent edits, one holding the scorer it can never reach step 3 → fix the wall clock per attempt. comparability comes from the budget, not the attempts step 4 → write the never-stop line verbatim or your agent becomes a slower human step 5 → add a second agent only after the first ships real commits. one git worktree each or they overwrite each other step 6 → at thirty agents, isolation costs more than it saves. that's when they need one shared DAG instead of thirty private histories 2.02 hours to 1.80 hours on code its author had already tuned. 90,900 stars in four months. read this PDF and paste it into your Claude, you won't regret it bookmark, then read the article on building graphs from scratch ↓

Carnage

53,972 görüntüleme • 1 ay önce

iit's wild that this still isn't the default way people use AI. Andrew Ng, a co-founder of Google Brain, gave a talk that crossed 2 million views: stop feeding your AI a folder of notes, build it a graph it can actually think with. his point is simple, stop making your AI read the whole vault to answer one thing. give it a graph, a router that points, an index that scores, edges that link, and it walks straight to the answer. it compounds, cheaper and faster the more you add. here's the whole thing: > point Claude at your notes and have it write a tiny router, your CLAUDE.md > build an index, one line per note, so it always knows where an answer lives > keep each note to one idea, and link the ones that depend on each other > make retrieval run as code, so it scores and opens the right files before the model thinks > tell it to prove the graph beats a flat folder on speed and cost, then keep the index fresh on every write set it up once and your AI stops guessing. it already knows your world before you type a word. full 12-step guide below. bookmark this.

iit's wild that this still isn't the default way people use AI. Andrew Ng, a co-founder of Google Brain, gave a talk that crossed 2 million views: stop feeding your AI a folder of notes, build it a graph it can actually think with. his point is simple, stop making your AI read the whole vault to answer one thing. give it a graph, a router that points, an index that scores, edges that link, and it walks straight to the answer. it compounds, cheaper and faster the more you add. here's the whole thing: > point Claude at your notes and have it write a tiny router, your CLAUDE.md > build an index, one line per note, so it always knows where an answer lives > keep each note to one idea, and link the ones that depend on each other > make retrieval run as code, so it scores and opens the right files before the model thinks > tell it to prove the graph beats a flat folder on speed and cost, then keep the index fresh on every write set it up once and your AI stops guessing. it already knows your world before you type a word. full 12-step guide below. bookmark this.

KingWilliam

15,099 görüntüleme • 1 ay önce

Anthropic hired this engineer at $250k-$600k/year because he can built projects with zero lines of code - in Claude chat: in this 30-min workshop he showed exactly how, using loops - from 0% to 100% here's workflow, step by step: step 1 → set your rules once at the top: "no preamble, use artifacts, you're a React expert" - every reply after that stays on rails step 2 → load the docs plus a random Medium article about the API - the human explanation teaches it more than the reference step 3 → wrap your ask in XML tags and tell it to ask you questions first. Answer 5, and the scope is locked before a single file exists step 4 → now run the loop: screenshot the broken UI, paste it back, let it fix, screenshot again - each pass gets closer - this is the agentic loop in its simplest form step 5 → push to GitHub, then paste the repo link in - every next loop iteration builds on working code, not chat history most people never did this - it pays for itself on day one watch & bookmark - then read how to get Claude Certified Architect in the article below ↓

Anthropic hired this engineer at $250k-$600k/year because he can built projects with zero lines of code - in Claude chat: in this 30-min workshop he showed exactly how, using loops - from 0% to 100% here's workflow, step by step: step 1 → set your rules once at the top: "no preamble, use artifacts, you're a React expert" - every reply after that stays on rails step 2 → load the docs plus a random Medium article about the API - the human explanation teaches it more than the reference step 3 → wrap your ask in XML tags and tell it to ask you questions first. Answer 5, and the scope is locked before a single file exists step 4 → now run the loop: screenshot the broken UI, paste it back, let it fix, screenshot again - each pass gets closer - this is the agentic loop in its simplest form step 5 → push to GitHub, then paste the repo link in - every next loop iteration builds on working code, not chat history most people never did this - it pays for itself on day one watch & bookmark - then read how to get Claude Certified Architect in the article below ↓

codila

291,670 görüntüleme • 1 ay önce