Suresh

[Qwen @Alibaba_Qwen]

Performance of Qwen3.8-27B:

[Thomson Reuters-Imperial Frontier AI Research Lab @tri_fair_lab]

Super excited for these new frontier models developed by our lab members!

[Jonathan Richard Schwarz @schwarzjn_]

We've just made a major finding for SovereignAI 🚨:

Take any open-weight model (here: Qwen3.5-397B), apply our π-shaped Continual Learning, and own a genuine frontier model competitive with Opus 4.8 for ~$450k in compute.

Full tech report + open-source models coming soon!

[Sakana AI @SakanaAILabs]

Introducing Sakana Fugu: A full multi-agent orchestration system accessible via a single model API.

Our ‘Fugu Ultra’ model matches the performance of Fable and Mythos, delivering frontier capability without the risk of export controls.

Try it: https://t.co/hhO6qTawgb 🐡

[Paul Iusztin @pauliusztin_]

I spent months optimizing GraphRAG retrieval.

But it turned out I was optimizing the wrong thing....

The biggest knowledge graph problems usually occur during ingestion (even though most conversations focus on retrieval).

Every new document creates a risk of graph corruption.

This is why I now think about knowledge graph ingestion as a 5-step pipeline:

1/ Extraction

Convert raw text into entities and relationships.

For example: Person → WORKS_AT → Organization

The goal is to extract what your ontology cares about.

2/ Resolution

This step standardizes names.

For example:

NYC → New York City
P Morgan → JPMorgan Chase
Jon Smith → John Smith

Most importantly, nothing has been merged yet.

3/ Embedding

Next, embed the entity's full context (not just the name).

Think:

Type
Attributes
Metadata
Relevant content

Because identity lives in context.

4/ Deduplication

Many systems fail here.

Because:

Apple the company ≠ Apple the fruit
Paris, France ≠ Paris, Texas
Two people can share the same name

Resolution answers naming.
Deduplication answers identity.

Those are two completely different jobs.

5/ Routing

Finally, the system decides:

Merge
Human review
Create new node

And the best systems follow a simple rule:

Evidence strength = permission strength.

Weak evidence → new node
Strong evidence → merge
Uncertain evidence → human review

Because false merges are expensive.

A duplicate node is annoying.

But a corrupted graph can silently poison retrieval quality for months.

My biggest takeaway?

Knowledge graph quality isn't determined by your retrieval strategy...

It's determined by the pipeline that creates the graph in the first place.

Get these five steps right... and retrieval becomes much easier.

P.S. I break down the full pipeline, entity resolution, deduplication thresholds, review queues, and production architecture in Decoding AI Magazine

Check it out here: https://t.co/iYSkSC0tJX

[Alexey Grigorev @Al_Grigor]

When your agent fails, you need to answer specific questions:

- Which step was running?
- Which tool was called?
- What arguments did we send to the tool?
- What did the tool return?
- Was this a timeout, a bad input, a rate limit, or an LLM decision?
- How long did each step take?
- How much did it cost?
- Can we retry safely?
- Can we resume from the failed step?

Without traces and per-step history, you are mostly reading logs and guessing.

For an agent workflow, I would want to see the run ID, step ID, prompt version, model response, tool name, tool arguments, tool response, latency, token usage, error, and retry count.

On June 16, Nicholas Lotz will run a DataTalksClub workshop on Running Durable Agents in Production.

We will discuss the execution layer of the agent loop: state, retries, recovery, human approvals, observability, and deployment.

Tuesday, June 16
4:30 PM - 6:00 PM CET
YouTube

Register here: https://t.co/fukTRTe5Ir

[Chip Huyen @chipro]

My 8000-word note on agents: https://t.co/uELWfPtS9N

Covering:

1. An overview of agents

2. How the capability of an AI-powered agent is determined by the set of tools it has access to and its capability for planning

3. How to select the best set of tools for your agent

4. Whether LLMs can plan and how to augment a model’s capability for planning

5. Agent’s failure modes

AI-powered agents are an emerging field with no established theoretical frameworks for defining, developing, and evaluating them. This post is a best-effort attempt to build a framework from the existing literature, but it will evolve as the field does.

As always, feedback is much appreciated!

[Akshay 🚀 @akshay_pachaar]

about loop engineering.

everyone's saying the same thing this week. you don't prompt agents anymore, you design loops that prompt them.

here's the job that loop hands right back to you.

a loop running unattended is also a loop failing unattended.

loop engineering takes you off prompting. it takes you off curating context. it takes you off babysitting a single run. it does not take you off debugging. it just moves the debugging somewhere worse, into runs you were never watching, with far too much of it to read through by hand.

even the loop engineering posts admit this themselves, usually somewhere near the end. you can only walk away from a loop if you trust the thing checking it. a checker you don't trust drops you right back into reading every output by hand, which is the exact work the loop was supposed to take off you.

so stack the layers up, prompt, context, harness, loop, and one job survives all of them. closing the loop on failure. the leverage point moved. debugging stayed exactly where it was.

i was writing about this exact gap yesterday, before the loop talk picked up today. the idea was simple. make debugging its own loop. a failure leads to a root cause, a proposed fix, a rerun against the exact inputs that broke, and a test that locks it out for good. the checker gets built from your real failures instead of guessed at up front.

Opik, the tool i was writing about, does exactly this. a built-in agent reads the trace, finds the root cause, proposes a diff, you approve it, and that failure becomes a permanent regression test. every break you debug makes the loop a little harder to break next time, which is the kind of checker the loop engineering crowd keeps saying you need before you walk away.

if you're designing loops you actually plan to walk away from, it's worth a look.

Opik is 100% open-source under Apache-2.0 license.

GitHub repo: https://t.co/MEC26owCdo

(don't forget to star 🌟)

loop engineering moved the leverage point. it didn't remove the engineer who still has to close the loop when something breaks.

the full article, Your Agent Harness Should Repair Itself, is quoted below.

[Akshay 🚀 @akshay_pachaar]

https://t.co/1y913VNynx

[Suresh @Sureshdamera]

@MrAhmadAwais 🙋

[Andrew Ng @AndrewYNg]

How we prompt AI is very different in 2026 than 2022 when ChatGPT came out.

I'm teaching a new course, AI Prompting for Everyone, to help you become an AI power user — whatever your current skill level.

It covers skills that apply across ChatGPT, Gemini, Claude, and other AI tools. How to use deep research mode for well-researched reports on complex questions. How to give AI the right context, including more documents and images than most people realize you can provide. When to ask AI to think hard for several minutes on important decisions like what car to buy, what to study, or what job to take. And how to use AI to generate images, analyze data, and build simple games and websites.

I also cover intuitions about how these models work under the hood, so you know when to trust an answer and when not to.

Along the way, you'll see flying squirrels, a creativity test, some of my old family photos, and fireworks.

Join me at https://t.co/tcQc4iJAJG

[Suresh @Sureshdamera]

@budapp @ycombinator Let me try !

[ClaudeDevs @ClaudeDevs]

Claude Code in the terminal will now show recaps when you switch focus away from the session and then come back.

This should help you stay more in flow while multi-clauding.

[Kimi.ai @Kimi_Moonshot]

Meet Kimi K2.6: Advancing Open-Source Coding

🔹Open-source SOTA on HLE w/ tools (54.0), SWE-Bench Pro (58.6), SWE-bench Multilingual (76.7), BrowseComp (83.2), Toolathlon (50.0), Charxiv w/ python(86.7), Math Vision w/ python (93.2)

What's new:
🔹Long-horizon coding - 4,000+ tool calls, over 12 hours of continuous execution, with generalization across languages (Rust, Go, Python) and tasks (frontend, devops, perf optimization).
🔹Motion-rich frontend - Videos in hero sections, WebGL shaders, GSAP + Framer Motion, Three.js 3D.
🔹Agent Swarms, elevated - 300 parallel sub-agents × 4,000 steps per run (up from K2.5's 100 / 1,500). One prompt, 100+ files.
🔹Proactive Agents - K2.6 model powers OpenClaw, Hermes Agent, etc for 24/7 autonomous ops.
🔹Claw Groups (research preview) - bring your own agents, command your friends', bots & humans in the loop.
-
K2.6 is now live on https://t.co/YutVbwktG0 in chat mode and agent mode.
For production-grade coding, pair K2.6 with Kimi Code: https://t.co/uvoSJKyGCY
-
🔗 API: https://t.co/EOZkbOwCN4
🔗 Tech blog: https://t.co/9wWvgIQSS3
🔗 Weights & code: https://t.co/Be0hjs2RTP

[Andrej Karpathy @karpathy]

Agency > Intelligence

I had this intuitively wrong for decades, I think due to a pervasive cultural veneration of intelligence, various entertainment/media, obsession with IQ etc. Agency is significantly more powerful and significantly more scarce. Are you hiring for agency? Are we educating for agency? Are you acting as if you had 10X agency?

Grok explanation is ~close:

“Agency, as a personality trait, refers to an individual's capacity to take initiative, make decisions, and exert control over their actions and environment. It’s about being proactive rather than reactive—someone with high agency doesn’t just let life happen to them; they shape it. Think of it as a blend of self-efficacy, determination, and a sense of ownership over one’s path.

People with strong agency tend to set goals and pursue them with confidence, even in the face of obstacles. They’re the type to say, “I’ll figure it out,” and then actually do it. On the flip side, someone low in agency might feel more like a passenger in their own life, waiting for external forces—like luck, other people, or circumstances—to dictate what happens next.

It’s not quite the same as assertiveness or ambition, though it can overlap. Agency is quieter, more internal—it’s the belief that you *can* act, paired with the will to follow through. Psychologists often tie it to concepts like locus of control: high-agency folks lean toward an internal locus, feeling they steer their fate, while low-agency folks might lean external, seeing life as something that happens *to* them.”

[Perplexity @perplexity_ai]

Computer now connects with Plaid to link bank accounts, credit cards, and loans.

Track spending in detail, build custom budget tools, and visualize your net worth alongside your investment portfolio.

[Z.ai @Zai_org]

SOTA on SWE-Bench Pro (58.4): GLM-5.1 delivers significant leaps in coding and agentic performance.

[Paweł Huryn @PawelHuryn]

After the llama.cpp fix, we can finally use gemma-4 with Claude Code:

Step 1:
- Windows: winget install llama.cpp
- MacOS: brew install llama.cpp
More: https://t.co/4DpKZPNTZH

Step 2:
- llama-server -hf ggml-org/gemma-4-E2B-it-GGUF (https://t.co/41xLS7L5xD) OR
- llama-server -hf ggml-org/gemma-4-E4B-it-GGUF (https://t.co/WiBubuQSu5)

Step 3: Add this to your settings.local.json
{
"env": {
"ANTHROPIC_BASE_URL": "http://127.0.0.1:8080"
},
"model": "gemma4"
}

P.S. Fixes for Ollama and mlx-lm are still in progress.

[Om Patel @om_patel5]

SOMEONE MADE IT SO YOU CAN CODE WITH 174 AI MODELS FROM 23 PROVIDERS FOR FREE

one npm package and one install: "npm i -g free-coding-models"

switch between any model instantly. benchmark them against each other in real time to see which one actually codes best for your use case.

no subscriptions. no API keys. no cost.

174 models. 23 providers, all free, all from your terminal.

if you're tired of paying for 3 different AI subscriptions just to compare which model codes better, this is it

[Boris Cherny @bcherny]

I wanted to share a bunch of my favorite hidden and under-utilized features in Claude Code. I'll focus on the ones I use the most.

Here goes.