marfin
@marfinxx • 5,849 subscribers
ai enthusiast || full-time in tech || researcher || content creator
Shorts
Videos
this is pure f*cking treasure A Stanford AI research group found how to orchestrate Claude Opus 5.5 and GPT-6.1 Sol together, and it completely breaks the search scaffolding wall most developers try to combine frontier models by chaining prompts in one context window or hardcoding rigid evolutionary loops. you burn tokens on context bloat and freeze models into fixed search rules that out-date themselves within 5 iterations Stanford's architecture eliminates human-designed search scaffolding and splits the cognitive stack: > search director: Claude Opus 5.5 plans the search, querying a persistent idea-graph where MAP-Elites and MCTS reduce to single Cypher queries > candidate proposer: GPT-6.1 Sol explores high-entropy code variations inside isolated execution sandboxes > zero context bleeding: sessions reset after each iteration to prevent prompt bloat while the graph stores lineage > evaluator isolation: candidate code never touches the scoring process, stopping reward hacking and test leakage cold > meta-agent distillation: an offline meta-pass extracts verified lessons and updates search guidance across branches the benchmark metrics outclass standard discovery baselines: > 3.2x lower model spend than fixed evolutionary frameworks > 1st place rank across 7 competitive AtCoder heuristic contests against human competitors > beats published SOTA on Anthropic kernel builder and 11 mathematical optimization tasks > 0% reward hacks: candidate-controlled metric tampering eliminated Opus directs the search graph. Sol explores the code you stop writing rigid search harnesses. you let frontier models own the discovery loop
marfin282,003 görüntüleme • 1 ay önce
this is pure f*cking treasure A Stanford research group found how to orchestrate Claude Opus 5.5 and GPT-6 Astra together, and it completely breaks the resampling wall most developers think test-time compute means running 32 blind retries on one model. you burn API tokens repeating the same 2-3 error clusters in loops Stanford's paper (arXiv:2608.05643) splits the compute between two different brains: > breadth search: GPT-6 Astra runs high-entropy exploration (T=0.8) to discover divergent solution paths > step audit: Claude Opus 5.5 scans each step at T=0.0 and catches the exact logic fallacy > local surgery: Opus rewrites only the broken step instead of dumping the whole reasoning chain > verifier-free consensus: majority voting locks the proof without relying on drift-prone PRMs the benchmark metrics outclass standard Best-of-N sampling: > 91.2% recovery rate on detected reasoning flaws > under 1.8% regressions on correct branches > MATH500 jumps from 29.6% to 58.0% (+28.4% absolute gain) > AMC-2023 improves by +7.5% with zero reward models Astra explores the maze. Opus repairs the logic you stop burning tokens on blind retries. you run verified reasoning depth
marfin235,178 görüntüleme • 1 ay önce
It is becoming f*cking dangerous A 21-year-old Chinese engineer just ran 320 Claude Code agents in parallel and hooked them to an adversarial verification loop so none of them could hallucinate The live telemetry dashboard looks absurd: - 320 agents writing, checking, and compiling concurrently - Sub-85 ms deterministic verification against ground-truth source trees - Dual-pass consensus over 120 target codebases with zero drift - Isolated sandbox harness with state hashing and zero token waste The trick is looping on evidence rather than confidence: the graph fans out 320 worker nodes, the harness locks the environment, and the adversarial verifier refuses to stop until consensus hits 100% An engineering agency would bill six figures and two months for this. He pulled the entire dataset in a single overnight run This is what happens when you stop treating Harness, Loop, and Graph engineering as separate toys. Study the full master architecture breakdown below
marfin32,064 görüntüleme • 23 gün önce
this is pure f*cking insane Anthropic just showed what 100 sub-agents running simultaneously inside Claude Code actually looks like an autonomous terminal spider crawls across 100 sandboxes in real time: ripping out fatal bugs, verifying AST diffs, and crowning the sole survivor run an elimination tournament with /arena claude /arena --agents 100 --seed 7 --waves 10 Opus 5.5 spawns 100 diverse problem-solvers across 2,160 strategy decks Sonnet 5.5 pairs them in head-to-head duels inside isolated sandboxes Adversarial judges attack every solution at three critical choke points: > before code executes: does the architecture hide silent race conditions or lock contention? > when input scale multiplies: does memory explode to O(N^2) or leak file descriptors? > before marking done: does a single unhandled timeout crash the entire pipeline? 100 spawn. 50 attack. 1 battle-tested survivor ships The core engineering shift: zero context bleeding If 100 agents share one chat window, they copy each other's hallucinations within 2 prompts Arena locks each agent into an isolated sandbox, forces 5 rounds of brutal peer critique, and lets a blind judge eliminate flaws Spawn on diversity. Eliminate on fatal flaws. Ship the survivor - the full tournament loop > wave 1-10: 100 diverse briefs generated across 2,160 reasoning seeds > round 1: 50 head-to-head matches paired with segregated reasoning styles > round 2: autonomous spider crawler inspects AST trees and extracts fatal bugs > round 3: defenders get one revision round to patch verified vulnerabilities > round 4: blind judge scores survivors on a strict 100-point rubric > grand finals: 1 hardened, attack-proof solution survives into production paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for the 100-agent tournament arena: 1. Audit ~/.claude/skills and project .claude/skills for the arena-skill package > Clone from repo if missing > Configure 10 execution waves with 10 concurrent sub-agents to avoid rate limits > Assign isolated sandbox directories in .arena/runs/ to prevent context bleeding 2. Set up tournament bracket rules in ~/.claude/settings.json: > Enable sub-agent spawning with CLAUDE_CODE_EXPERIMENTAL_SUBAGENTS=1 > Pin lead evaluator model to Opus 5.5 and tournament workers to Sonnet 5.5 3. Initialize rubric.md with a 100-point blind scoring matrix across correctness, completeness, and edge-case handling 4. Add a rule to ~/.claude/CLAUDE.md: any single-agent answer on mission-critical architecture must survive a 100-agent arena bracket before merge Show every configuration diff first. Do not apply edits until confirmed"
marfin39,152 görüntüleme • 1 ay önce
this is pure f*cking treasure Leading AI researchers (Anthropic, Google, OpenAI) found how to orchestrate Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5, and GPT-6.1 Sol together, and it completely breaks the agentic context rot wall most developers try to combine frontier models by chaining prompts in one context window or hardcoding rigid retry loops. you burn tokens on context bloat and freeze subagents into contradictory schemas that hallucinate within 5 iterations their cognitive architecture eliminates monolithic prompt chaining and splits the agentic stack: > syntax triage: Claude Haiku 5.5 elides raw AST syntax into typed interfaces ( candidate proposer: GPT-6.1 Sol explores high-entropy code variations inside isolated execution sandboxes (+15.47% win rate) > code synthesis: Claude Sonnet 5.5 acts as the dedicated execution workhorse (70.6% terminal-bench) generating verified AST diffs > causal supervisor: Claude Opus 5.5 anchors the 1M context outer loop, coordinating multi-turn verification and semantic state > zero context rot: Ebbinghaus exponential decay (tau=0.35) and Byte-0 prefix locks purge degraded noise while retaining 99.2% memory the benchmark metrics outclass standard agent baselines: > 91.4% reduction in token burn: Byte-0 KV-cache locking delivers 99.2% prefix hits > +31.4% net increase in verified PR merge rate across 184,200 multi-turn sessions > 78% lower latency by delegating pre-execution syntax checks away from the frontier reasoning models > 0% context rot: non-volatile semantic ledger prevents hallucinations from polluting the persistent graph Haiku strips the syntax. Sol explores the sandboxes. Sonnet writes the diffs. Opus guards the graph you stop treating context windows like infinite scratchpads. you let frontier models orchestrate into a typed cognitive mesh
marfin34,338 görüntüleme • 1 ay önce
this is f*cking insane, Claude 5.5 agents turned an entire repository into an autonomous engineering harness you can run locally Andrej Karpathy gave 15 Claude 5.5 agents three frontier models and one assignment: build an autonomous software harness that writes, tests and verifies production PRs without human babysitting pick a broken codebase, trigger an issue and watch Haiku 5.5 intercept tool calls while Sonnet 5.5 fans out across 15 parallel branches switch between execution layers while keeping the same workspace. inspect AST file hashes, terminal traces and token savings beside the live river give each model a specific tier: -> Haiku 5.5 intercepts tool calls, hashes file states and filters tokens ( Sonnet 5.5 executes parallel graph routing across 15 sub-agents with 70.6% on Terminal-Bench 4.0 -> Opus 5.5 directs causal loop verification and attacks candidate patches with adversarial test suites -> sandbox runners execute isolated container checks to enforce zero cascading failures a generated code patch can look convincing while failing silent edge cases the loop rejects self-reported model confidence and requires deterministic evidence: passing pytest exit codes, zero linter warnings and strict schema validation before accepting the PR every candidate patch has to show: > the failing test reproduced cold > the exact AST diff generated > zero regression across the existing test suite > the adversarial trace proving the fix holds under stress the harness solved 32 complex terminal tasks across 15 sub-agents in 1.9 minutes. 99.2% passed on the first run within stated SLO budgets; token spend dropped by 88.4% compared to single-agent intern mode give Claude Code your repository, then ask: "Turn this repository into an autonomous production harness: 1. Deploy Haiku 5.5 as the harness interceptor: cache SHA-256 file hashes, strip AST context and filter tool calls before tokens hit the window 2. Assign parallel task branches to Sonnet 5.5 sub-agents using shared git checkpoints and terminal benchmarks 3. Have Opus 5.5 run causal loop verification on every patch. Attack candidate fixes with adversarial edge cases and require passing pytest exit codes 4. Enforce deterministic sandbox containers for all tool calls and log verified telemetry before opening the production PR" start with one subsystem and enforce deterministic test loops before adding more agents include file state hashes and sandbox constraints so the next run reproduces from a clean checkout watch the agents at work below
marfin24,182 görüntüleme • 29 gün önce
this is pure f*cking treasure A Stanford AI research group found how to orchestrate Claude Haiku 5.5, GPT-6.1 Sol, Claude Sonnet 5.5, and Claude Opus 5.5 together, and it completely breaks the agentic context rot wall most developers try to combine frontier models by chaining prompts in one context window or hardcoding naive retry loops. you burn tokens on context bloat and freeze models into contradictory schemas that fail within 5 iterations Cambridge's architecture eliminates human-designed prompt scaffolding and splits the cognitive stack: > syntax triage: Claude Haiku 5.5 strips raw AST boilerplate into typed interfaces ( candidate proposer: GPT-6.1 Sol explores high-entropy code variations inside isolated execution sandboxes > code synthesis: Claude Sonnet 5.5 executes verified AST diffs that pass unit test suites > causal supervisor: Claude Opus 5.5 anchors the 1M-token causal outline graph, stopping hallucination loops and coordinating state commits > zero context rot: Byte-0 prefix locks and exponential decay (tau=0.35) evict degraded noise while retaining 99.2% verified memory the benchmark metrics I calculated from my own empirical runs outclass standard discovery baselines: > 88.4% lower token spend: Byte-0 KV-cache locking delivers 99.2% prefix hit rates ($0.74 vs $4.80 per verified PR) > +31.4% net increase in verified PR merge rate across multi-turn sessions (98.9% test pass rate) > 78% lower latency by offloading syntax pre-filtering to sub-35ms passes > 0% context rot: non-volatile semantic ledger stops regression cascades cold Haiku strips syntax. Sol explores code. Sonnet writes diffs. Opus guards the graph you stop treating context windows like infinite scratchpads. you let frontier models own the cognitive loop
marfin16,347 görüntüleme • 1 ay önce
Daha fazla içerik yok.