Java Israel 🇳🇬🇺🇸

Software Engineer, Trader, Patriot, XRP Fan

[Jey @0xJeyx]

Anthropic engineer:

"It's important that the task verifier is nearly perfect, otherwise Claude will solve the wrong problem."

Nicholas Carlini ran 16 Claudes in parallel.

Small tasks, and they flew. Each agent took a different one.

One big task, and all 16 hit the same bug and overwrote each other's fix.

Adding agents did nothing.

What unlocked it was GCC. An old compiler that already knew every right answer, sitting outside the group and telling each agent which piece it broke.

You do not scale a graph with more agents. You scale it with a judge they cannot argue with.

[Lunar @LunarResearcher]

8 ways to cut your agent bill

most agent bills are not one expensive call

they are the same cheap call ten thousand times

1) prompt caching

the system prompt and tool schemas stay the same between turns

cache the stable prefix and stop paying full price for it

use it the moment your agent makes a second call

LMCache reuses KV cache across requests and serving engines

→ https://t.co/SdEfRDESjQ

2) model routing

send classification extraction and formatting to a smaller model

keep the frontier model for the step that actually needs it

use it when most calls are routine but one part is genuinely hard

RouteLLM routes simpler requests to cheaper models while protecting quality

→ https://t.co/Eb2a68FrN4

3) skip the model entirely

dates regex arithmetic sorting and validation are code problems

code is cheaper faster and does not hallucinate

use it whenever the answer can be deterministic

Dateparser turns human readable dates into structured values without an LLM

→ https://t.co/tbrQHJdbx5

4) early exit

stop the loop when the evaluator passes the result

do not keep running toward the turn cap out of habit

use it whenever the loop has a measurable success condition

LangGraph helps you build stateful loops with explicit control over execution

→ https://t.co/KeseBZ4ALL

5) retry budget

give the run two attempts and then hand it to a human

the third retry usually repeats the second failure

use it before a broken tool can retry all night

Tenacity provides explicit stop wait and retry policies for Python

→ https://t.co/hqmVOdgXJ5

6) tool result cache

the same file read twice in one run returns the same bytes

cache tool results close to the loop and pay for the read once

use it when the agent revisits the same repo or endpoint

DiskCache provides a persistent disk backed cache for Python

→ https://t.co/w58pVBUE9k

7) batch what is patient

overnight work does not need instant responses

queue backfills evals and background jobs and process them together

use it whenever nobody is waiting on the next token

Prefect orchestrates scheduled and resilient Python workflows

→ https://t.co/y7kOWmf1gD

8) cap the output

ask for structured data instead of a paragraph when code consumes the answer

fewer output tokens means less cost and less parsing

use it anywhere a person will never read the raw response

Instructor turns model responses into validated structured outputs

→ https://t.co/EFQIhOEyc2

the cheapest token is the one you never send

the second cheapest is the one you send once

bookmark this

[Nishith Ravulakolu @nishithX26]

The struggle is real🥲

[Codez @0xCodez]

A senior Anthropic engineer just dropped 12-page PDF on "Graph Engineering" for multi-agentic systems.

The shift: your agents memory dies with their context window. A knowledge graph makes it permanent.

Extract → Resolve → Assemble → Query → Repeat

Every agentic graph has 5 stages:

• Extract: Haiku pulls entities and S-P-O triples. One call per doc. The Pydantic schema is the only training data.

• Resolve: Sonnet clusters "Edwin Aldrin" → "Buzz Aldrin" - zero string overlap - using descriptions as context.

• Assemble: canonical nodes, typed edges, provenance on every triple. One connected graph.

• Query: serialize a subgraph → Sonnet reasons over triples → every answer cites a specific edge.

Plug this into multi-agent systems as shared memory.

Workers write to it, evaluators fact-check against it, loops persist overnight with it.

This 12-page PDF changed how I'm building multi-agent systems today.

Read it now, then explore the article below.

[ai maxxer @agentsmaxxing]

This guy makes complex agent concepts surprisingly easy to understand.

If you're serious about agentic engineering,

Bookmark this.

[Words of Wise | Mindset Coach @Wordofwise_]

Your problem isn't consistency. It's the pattern your mind has been repeating for far too long.

Every choice makes that pattern stronger, whether it pushes you forward or holds you back.

Everything shifts when your actions stop depending on your mood.

[Words of Wise | Mindset Coach @Wordofwise_]

Laziness is often the name we give to a mind that's lost its direction, not its potential.

When you understand why you keep putting things off, action stops feeling like a battle. Everything begins to move differently.

[Venkatesh @Venkydotdev]

for real 😂

[Hanako @hanakoxbt]

6 agent patterns for AI engineers:

(explained with usage)

1) prompt chaining
→ split the task into fixed steps, each one checking the last.
→ use when the task decomposes cleanly and accuracy matters more than latency.

2) routing
→ classify the input first, then send it to the model or tool built for it.
→ use when inputs fall into distinct classes that need different handling.

3) parallelization
→ run several calls at once and merge them, either by splitting the work or voting on the same question.
→ use when subtasks are independent, or when one answer deserves several opinions.

4) orchestrator-workers
→ a lead model decides what the subtasks are at runtime, then delegates them.
→ use when you cannot list the steps in advance.

5) evaluator-optimizer
→ one model writes, another grades, the loop repeats until it passes.
→ use when you have clear criteria and iteration measurably helps.

6) autonomous agent
→ no fixed path. it plans, acts, reads feedback from the environment, and decides when it is done.
→ use when the steps are unknowable and you can afford the cost and the blast radius.

the first five are workflows: you wrote the path. only the last one writes its own.

most production systems people call agents are pattern 1, 2, or 5 with good error handling.

this taxonomy is from Anthropic's own writeup on building effective agents.

full breakdown in the article below.

[Keyfi Paylaşımlar @keyfipyIasimIar]

Dünyanın en hızlı internetine sahip olmayı hedefleyen bu adam, hız testini paylaştı.

[Oliver Prompts @oliviscusAI]

microsoft just released a tool that transcribes a full hour of audio at once, tracking who spoke and when.

it's called vibevoice

the 7b model processes the full recording in one shot instead of chunking it, so speaker identity and context never break across segments

→ full speaker diarization built in, not bolted on
→ structured timestamps for every speaker turn
→ supports 50+ languages

runs locally, no api costs.