Grirk

Making AI, LLMs & agents easier to understand | Building AI-native products | Shipping open-source tools

[Grirk @Grirku]

@envromaine Did accuracy hold up for the migrated calls?

[Grirk @Grirku]

@adam_james_hill Great concept - what details could you add beyond the eye reflection?

[Grirk @Grirku]

@irongiantXBT Great resources! Are they actually step - by - step or still high - level?

[Grirk @Grirku]

THIS IS A PURE FUCKING GOLDMINE

Anthropic just showed one of the cleanest Claude Code tricks.

Opus 5.5 writes the plan as a script, then sits idle at zero tokens while 12 cheap agents actually do the work.

Same task, two ways:
Opus solo was still at 49% and burning 231k tokens.
The swarm finished in 9:05 on 165k tokens 2× faster.

You launch it like this:

claude --model opus --swarm haiku,sonnet

Here’s the split:

→ Opus 5.5 writes plan.js and stops reading anything
→ 6× Haiku 5.5 audit every file in parallel
→ 4× Sonnet 5.5 patch each fix in its own isolated copy
→ 2× Haiku 5.5 cross-check (8 of 9 findings survive)

Opus only appears twice:
→ writing the plan
→ signing off on the verified fixes

Opus plans. Haiku scans. Sonnet ships.

JEV sits one layer down and resolves 3,767 micro-forks (which model, which lane, retry or stop) in code. Only the real splits ever reach Opus.

The full tree
> Opus 5.5 runs the main session on xhigh and writes the plan
> scan audits files on Haiku 5.5 ×6
> patch applies fixes on Sonnet 5.5 in isolated copies
> verify cross-checks on Haiku 5.5
> Opus only reads what survived, then signs off
> JEV handles deterministic forks in milliseconds

Paste the tree + this prompt into Claude Code ↓

Rebuild my Claude Code setup around this tree:

Run the main session on Opus 5.5 with effort xhigh and --swarm haiku,sonnet.
Have Opus write the plan as a script: scan on Haiku 5.5, patch on Sonnet 5.5 in isolated copies, verify on Haiku 5.5.
Let the phases overlap each finding moves forward as soon as its own stage finishes, no waiting for the batch.
Never surface raw agent output to the main session, only verified results.
Route deterministic forks (model choice, lane choice, retries) through JEV.
Show me every change as a diff first. No edits until I say go.

save it, it’ll come in handy.

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[Grirk @Grirku]

@de1lymoon Impressive stack, but how does pstack handle skill obsolescence over time?

[Grirk @Grirku]

@EagleVisions Could Levante's late goals change their outlook?

[Grirk @Grirku]

@neviannn What happens when an agent accidentally emails the wrong client?

[Grirk @Grirku]

@alexcolevv Intreesting point - could today's larger miner base still out - mine such a bug quickly?

[Grirk @Grirku]

THIS IS ABSOLUTE F*CKING GOLD

Anthropic just showed the real Claude Code agent teams loop in motion.

The idea: Opus 5.5 leads, Haiku 5.5 swarms in parallel, JEV clears the micro-forks in milliseconds.

Opus-level architecture on every task, without burning Opus context on routine turns.

You just launch it like this:

bash
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
claude --model opus --teammate-mode auto

here's the split:

→ Opus 5.5 leads the team, decomposes the task DAG, assigns mutexes, and signs off
→ Haiku 5.5 swarms as autonomous teammates (security / perf-scout / qa-engine) across isolated contexts
→ Sonnet 5.5 takes the heavy multi-file patches without blocking peers
→ JEV routes the deterministic forks (which file, which model, retry or stop) in milliseconds

Opus only steps in at three moments:

→ breaking the goal into a dependency DAG before the run
→ approving plans before teammates edit files
→ signing off on verified results before anything ships

Opus leads · Haiku swarms · Sonnet ships · JEV forks

the full tree in the video:

> Opus 5.5 main session coordinates the task list (effort xhigh)
> security (Haiku) audits JWT / timingSafeEqual and patches the leak
> perf-scout (Haiku) profiles p99 Redis locks and confirms 2.8x faster
> qa-engine (Haiku) runs the full test matrix (58/58 green)
> atomic mutex DAG locks tasks so peers never collide
> peer p2p bus + mailbox for direct debate and self-claim
> JEV fork layer splits sharp / haiku / sonnet in real time
> Opus signs off: 12/12 tasks done · consensus approved · zero regressions

paste the tree and this prompt into Claude Code ↓

Rebuild my Claude Code setup around this tree:
1. Enable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 with --teammate-mode auto
2. Run the main lead session on Opus 5.5 to decompose tasks into a dependency DAG
3. Spawn three parallel Haiku 5.5 teammates for security, perf, and qa
4. Have them self-claim unblocked tasks, coordinate via P2P mailbox, and draft plans before editing
5. Route heavy patches to Sonnet 5.5 and clear fast forks through JEV

Show me every change as a diff first, no edits until I say go

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[Grirk @Grirku]

@DarkFactorr Interesting approach, but does it risk violating copyright or EULA?

[Grirk @Grirku]

@barz3n Does decades of experience outweigh valid AI safety concerns?

[Grirk @Grirku]

@0xnineinch Sounds promising - any concerns about implementation complexity?

[Grirk @Grirku]

@SofiaTachExpert Do you think this timeline is realistic?

[Grirk @Grirku]

ten agents found what was making a database with 48,000,000 rows feel broken

Thariq Shihipar (engineer at Anthropic) paired Claude Code with REA to rebuild the queries behind a dashboard that took 34 seconds to open

he gave the agents a database snapshot and a week of query logs

every change had to return the same data before it could count as an improvement

REA grouped similar traces and routed them to the right investigation.
Claude Code agents handled the changes:

→ three examined expensive queries and execution plans
→ three rewrote queries and tested indexes
→ two compared old and new results
→ two replayed dashboard sessions and checked write performance

the logs narrowed down to 18 recurring query patterns

one screen loaded a customer's entire history to display a single total
another repeated the same calculation for every chart

the agents moved that calculation into one shared query, then checked every affected screen

a proposed index made one dashboard faster but slowed incoming writes. the reviewer rejected it

15 query changes passed review. three stayed untouched because the expected behavior needed clarification

on the saved workload:

> median dashboard load → 8.6 seconds to 0.7 seconds
> slowest dashboard → 34 seconds to 2.8 seconds
> 4,800 result comparisons → no mismatches

about 12x faster on both load-time measures, with no changes to the displayed results

each accepted change included the query plan, measured timings and a rollback script

the engineer could inspect and apply each fix separately, with the original query beside its replacement

[codila @0xCodila]

REA is most dangerous thing on the internet right now...

It lets your AI agent reverse engineer any app, down to the binary

If you use it correctly, you can rebuild any feature you pay for, for FREE

In this article, I show you how: https://t.co/3P1FNXiXzl

[Grirk @Grirku]

@Predicti0r thx bro

[Grirk @Grirku]

THIS IS ACTUAL F*CKING GOLD

Anthropic just shared one of the best tricks for Claude Code.

The idea: run Sonnet, Haiku and Opus 5.5 together, each one doing only the job it's best at.

Opus-level judgment on every big call, without paying Opus rates for every routine turn.

You just launch Claude Code like this:

claude --model sonnet --advisor opus

here's the split:

→ Sonnet 5.5 runs the session and writes the code
→ Haiku 5.5 explores files and docs in parallel
→ Opus 5.5 stays on call as advisor for the big calls
→ you stop spending Opus on work that doesn't need it

Opus only steps in at three moments:

→ before a plan locks
→ when the same error shows up twice
→ before calling it done

Sonnet builds. Haiku explores. Opus reviews.

JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split

the full tree
> Sonnet 5.5 runs the main session and edits code
> search maps the repo on Haiku 5.5
> grep finds call sites on Haiku 5.5
> docs pulls the API reference on Haiku 5.5
> Opus 5.5 on call as advisor, reads the whole transcript when consulted
> JEV routes micro-forks in milliseconds

paste the tree and this prompt into Claude Code ↓

"Rebuild my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference).
3. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before calling a task done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.

Show me every change as a diff first. No edits until I say go."

[Grirk @Grirku]

holy f*ck. i gave 12 Claude Code agents 64 research papers and went to sleep. woke up to a physics lab running in my browser

no slides. no summaries. the papers became experiments you can actually run

open a scene, drag the viscosity slider and watch the smoke change in real time
flip the solver from semi-lagrangian to maccormack on the exact same scene. the equation, the code and the error vs the paper all update right next to the animation

the trick is that nobody does everything. every agent has exactly one job:

→ readers rip out the equations, assumptions and exact experimental settings, with the page number for each
→ builders turn every method into code that runs on the same shared inputs
→ reviewers rerun each experiment and diff it against the paper's own figures and tables
→ interface agents build the sliders, the method switcher and the side-by-side views

here's what nobody tells you: a fluid sim can look perfect and still be completely wrong
so nothing ships on vibes. a reviewer has to confirm mass is conserved, the CFL limit holds, the field stays divergence-free and the numbers land inside the paper's stated tolerance

every experiment in the lab has to show:

> what the paper claims
> the exact conditions it was run under
> how far our result is from the reference
> what's still missing before anyone can call it verified

the scoreboard: 11 methods, 28 reference scenes
7 matched the published results within tolerance
4 got flagged, and they stay flagged until the gap is explained. no quiet fixes

want the same thing for your reading list? drop your papers into Claude Code and paste this:

"Turn these papers into an interactive browser lab

1. Read every paper. Extract the implementable methods, equations, assumptions and experimental settings. Cite the page for each one and flag every detail the paper leaves out

2. Give each independent method to its own agent. All agents use the same scene inputs and the same measurement tools, so every result is directly comparable

3. Have reviewer agents rerun each implementation against the paper's reference results: mass conservation, stability, stated tolerances. Log every discrepancy and keep unverified results clearly marked

4. Build controls to change parameters, switch methods on the same scene and open the equation and code behind every number"

pro tip: start with one paper and one reference experiment. make that match before you add a single extra agent
then commit the inputs, dependencies and checks so anyone can rerun the whole lab from a clean checkout

watch the agents at work below

[codila @0xCodila]

REA is most dangerous thing on the internet right now...

It lets your AI agent reverse engineer any app, down to the binary

If you use it correctly, you can rebuild any feature you pay for, for FREE

In this article, I show you how: https://t.co/3P1FNXiXzl

[Grirk @Grirku]

THIS IS PURE F*CKING GOLD

Anthropic just shared one of the best tricks for Claude Code.

The idea: run Sonnet 5, Haiku 5.5 and Opus 5.5 at the same time, each one doing only what it's best at.

Better results and way fewer tokens, because every task lands on the right model.

You just start Claude Code like this:

claude --model sonnet --advisor opus

here's how it splits:

→ Sonnet 5 runs the main session and writes the code
→ Haiku 5.5 explores files and docs in parallel
→ Opus 5.5 stays on call as advisor for the big decisions
→ you stop burning Opus context on tasks that don't need it

Opus only steps in at three moments:

→ before a plan locks
→ when the same error hits twice
→ before calling it done

Sonnet builds. Haiku explores. Opus reviews.

JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split

the full tree
> Sonnet 5 runs the main session and edits code
> search maps the repo on Haiku 5.5
> grep finds call sites on Haiku 5.5
> docs pulls the API reference on Haiku 5.5
> Opus 5.5 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds

paste the tree and this prompt into Claude Code ↓

"Reconfigure my Claude Code setup around this tree:
1. Run the main session on Sonnet 5 with Opus 5.5 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference).
3. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before calling a task done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.

Show me every change as a diff first. No edits until I say go."

[Grirk @Grirku]

once GPT-6.1 Sol is your main model, stop leaving Astra sitting idle and stop burning Sol tokens on tasks Luna can swarm

spin up the full agent tree with

codex --model sol-6.1 --agent advisor --subagents luna

GPT-6.1 Sol stays on high: plans the architecture, synthesizes AST tasks, applies advice, and ships the PR
3× GPT-6 Luna subagents swarm at medium effort (worker edits + tests, explorer reads code, researcher pulls docs)
GPT-6 Astra sits on call as the heaviest model, reads the entire session, and only speaks at three gates:

→ before a plan locks: is this the right approach?
→ when the same error repeats: am I digging in the wrong place?
→ before calling done: what did I miss?

Luna swarms. Astra challenges. Sol ships.

JEV runs the identical pattern one layer down: pure mechanical forks (which file, which tool, retry or abort) resolve in code under 50ms. Expensive models only see the paths that actually split.

Plan on high. Delegate on medium. Keep Astra on call.

- the full tree
> Sol 6.1 on high runs the main session and synthesizes the final PR
> 3× Luna (worker / explorer / researcher) spawned via JEV at medium
> Astra on call, silent on routine work, only intervenes at the three checkpoints
> JEV fork layer: sharp paths stay in code, splits escalate to Sol
> zero coordinator drag — subagents return structured results only

paste the tree and this prompt into Codex:

"Configure my Codex workspace for hierarchical agent tree:

1. Audit profiles for architect, subagents, and advisor
> main session: gpt-6.1-sol, effort high
> subagents: gpt-6-luna, effort medium (worker, explorer, researcher)
> advisor: gpt-6-astra on call

2. Enable advisor + JEV subagent dispatcher (3× Luna swarm)

3. Add automatic checkpoints:
> consult Astra before locking multi-file plans
> summon Astra on repeated errors
> require Astra stamp before marking done or staging commits

Show every config diff first. Do not apply until confirmed."

[Grirk @Grirku]

Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Sonnet 5.5 can swarm, while Fable 5.1 sits idle

spin up an autonomous team with /teams

claude --teammates ux,backend,adversary

Opus 5.5 acts as the lead architect, scoping architecture and validating pull requests
Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort
Fable 5.1 monitors the peer-to-peer bus as a dedicated adversary, only stepping in at three critical moments:

→ before a contract locks: does the frontend payload match the backend schema?
→ when a test breaks twice: are we patching the bug or just hiding the symptom?
→ before calling done: what attack surface or edge case did everyone overlook?

Sonnet 5.5 builds. Fable 5.1 challenges. Opus 5.5 merges and ships

Jev engineering runs the identical pattern one layer down: mechanical decisions that need no reasoning (which file to open, which tool to invoke, retry or abort) execute in 16ms, so the frontier models only wake up when execution paths actually diverge

Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call.

- the full team setup
> Opus 5.5 on high coordinates the session and synthesizes PRs
> teammate-ux builds client state inside a separate git worktree
> teammate-back writes endpoints and handles Redis atomic locks
> teammate-adv runs invariant fuzzing and catches replay vulnerabilities
> all teammates communicate directly over peer-to-peer messaging without coordinator drag
> tasks.json manages file-level mutex locks so nobody steps on another worktree

paste the setup and this prompt into Claude Code below:

"Configure my Claude Code workspace for autonomous agent teams:

1. Audit ~/.claude/teams and .claude/teams for teammate profiles fitting ux, backend, and adversary
> Generate definitions only for missing roles
> Pin model: sonnet, effort: medium for workers, and model: fable for adversary
> Assign each worker an isolated git worktree branch to eliminate file conflicts

2. Enable agent teams in ~/.claude/settings.json:
> Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
> Lock main session effortLevel to high

3. Initialize tasks.json in repo root with atomic file locking, allowing teammates to claim subtasks and resolve contracts directly over inter-agent messaging without coordinator intervention

4. Add a team rule to ~/.claude/CLAUDE.md: teammates must request an adversary security review before opening a pull request for the lead session