Soe San Kyaw

[Sprytix @Sprytixl]

ANTHROPIC LEAD ENGINEER MAKING $2.3M/YEAR JUST LEAKED A 12-PAGE DOCUMENT - AND GOT FIRED 15 MINUTES AFTER PUBLISHING

most developers build loops - but almost every loop breaks in one of five ways, and each failure has a symptom visible from the outside without reading a single line of code

> Blind loop - the agent waits for a human to hand it work every morning - automating execution but not discovery
> Tangled loop - parallel agents share one directory and overwrite each other parallelism that destroys instead of multiplies
> Nodding loop - the agent grades its own work and approves it every time a loop that has never said no to itself is broken
> Amnesiac loop - results live only in the context window every morning the system wakes up with no memory of yesterday
> Manual loop - no trigger a human presses the button to start it that is not a loop that is a script waiting for a person

a real loop finds its own work - remembers what it did has something that can say no never lets two agents touch the same file and fires itself on a timer

remove any one of the five - and the loop either breaks or never starts

12 pages that changed how I build agentic systems today

[Ilya Shabanov @Artifexx]

https://t.co/dPUmdT36gX

[Avi Chawla @_avichawla]

Stanford researchers did it again.

They just built the agent-native version of Git.

When an agent works on a longer task, the run builds up a lot of state.

This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.

Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.

The tests start failing, and the run goes off track, although everything through step eight was correct.

By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.

The other options are a person stepping in to redirect it or restarting the whole run from step one.

That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.

The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.

It records what the agent said and which tools it called, but not the live state underneath.

That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.

Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.

Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.

Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.

Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.

Going back to a previous step is then a single call that forks from that commit and continues from the exact state.

The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.

Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.

In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.

Not everything is reversible though.

Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.

Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.

They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.

It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.

If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.

Shepherd Repo: https://t.co/5e8W5oxY6F

(don't forget to star it ⭐ )

That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.

Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.

Read it below.

[Sprytix @Sprytixl]

ANTHROPIC JUST LEAKED AN INTERNAL ENGINEERING DOCUMENT - AND IT SAVES SOLO DEVELOPERS $300,000 A YEAR

the highest-leverage AI systems are no longer prompt-driven - they are loop-driven - and that one shift changes everything

Generate → Evaluate → Remember → Schedule → Optimize → Recurse

six layers, one loop, improves itself without a human

Generation: the system produces its own solutions - no human writes the brief
Evaluation: a second layer measures quality - the thing that can say no
Memory: every execution retains useful discoveries - the loop gets smarter each cycle
Scheduling: the system decides what happens next - nobody manages the queue

Optimization: behavior updates based on what worked - static prompts eventually hit diminishing returns

Recursion: remove any single layer - and system performance drops significantly

the role of the human shifts from operator to architect - and AI transforms from a prediction engine into an adaptive production system

the future of AI engineering is recursive

[Codez @0xCodez]

https://t.co/hmpJtXuXCq

[connect24h @connect24h]

神ツール到来。PowerPoint職人の手戻り、ここからかなり減ると思う。hugohe3/ppt-masterがGitHub 33,093★、今日+589。AI生成なのに「画像貼り付けスライド」ではなく、編集できるreal PowerPointをnative shapes & animationsで吐く。強い。
資料生成AIで一番つらいのは、出力後に直せないこと。ppt-masterは任意documentから.pptx化し、自前template追従、speaker notesのaudio narrationまで行ける。すでにWeb版のChatgptとCluadeはこれに対応なので、CLIも対応できるのが素晴らしい。現場では「初稿をAI、微修正を人間」の流れが現実解なので、これのワークフロー化が今後進むのでは。
#AI駆動開発
https://t.co/FjpZhwrWDt

[Itaru Tomita / 冨田到 @itarutomy]

論文を「良い/悪い」で評価するのではなく、「どこをどう直せば良くなるか」だけを届けるAIシステム「PaperMentor」が公開された（https://arxiv[.]org/html/2606.08857v1）。

LaTeX論文執筆環境Overleafに直接統合されており、12の専門エージェントが序論・手法・結果など各セクションを分担してレビューする。NeurIPS・ICLR・COLMの査読コメント350本と研究者執筆ガイド32本をClaude Opus 4.5で蒸留・人手で品質確認した知識ベース（40以上のスキルファイル・1万6千語超）に加え、ターゲット学会の規定とユーザーが指定したお手本論文を参照してコメントを生成する。

たとえばこんなコメントが届く。

「手法セクション『標準的な手順でハイパーパラメータを調整した』は再現不可能。探索範囲・選択基準・試行数を明示せよ。ACLでは完全な再現情報が求められる」

文章の改変は一切しない。著者が読んで、判断して、書き直す。

80論文・14名のAI研究者による評価では、コメントの90.6%が行動可能（何をすべきか明確）、67.5%が妥当（内容が正確）と評価。スキルライブラリなしのGPT-5.2直接利用と比べると妥当性+6.5ポイント、行動可能性+4.1ポイントの改善。ただし知識ベースに沿う分コメントが長文化しやすく、簡潔さでは劣った。

指導教員へのアクセスが限られる若手研究者への格差縮小を目的に、オープンソースで公開中（https://github[.]com/jiarui-liu/overleaf）。

[Federico De Ponte @fedeponte1]

Introducing OpenPaper: Claude Code for research papers.

I typed one question. Five minutes later, it handed me a complete 8,330-word research paper with 30 citations.

Every citation is a real published paper with a working DOI, verified against 500M+ academic sources. Zero hallucinated references.

18 specialized agents do the research in parallel. Open source.

https://t.co/bqfWZDY9Z5

[Movez @0xMovez]

A Google AI Director just revealed, in a 16-minute lesson, a “4-layer agent system” they use inside Google.

this is the best explanation of self-improving agentic systems and loops I’ve seen so far.

People still paying 500$ for agentic courses, while Google makes it for free.

Agent Studio → Loops → Managed Agents → Antigravity → ADK 2.0 - thats the stack

Watch today, then read how to build agentic loops from sratch in article below.

[Jorge Bravo Abad @bravo_abad]

Two multi-agent AI systems for scientific discovery landed in the same Nature issue, with very different architectural bets. I covered the first, Robin, in my previous post. Here is the second one.

Juraj Gottweis and coauthors introduce Co-Scientist as a structured scientific thinking engine on Gemini 2.0. Six specialized agents (Generation, Reflection, Ranking, Evolution, Proximity, Meta-review) cooperate under a Supervisor in an asynchronous task framework. Hypotheses are produced, critiqued, debated and ranked in an Elo-based tournament, then refined iteratively.

The system scales test-time compute rather than model size, and the longer it thinks the better its hypotheses get, with no saturation across 203 research goals. Against expert "best guess" solutions and frontier reasoning models (OpenAI o1, o3-mini-high, DeepSeek R1), Co-Scientist won on Elo and was preferred by experts on novelty and impact.

The wet-lab validation spans three problems. For acute myeloid leukemia, the system proposed Binimetinib, Pacritinib and Cerivastatin as repurposing candidates, all active in AML cell lines, with Binimetinib reaching IC50 values as low as 2 nM. A novel candidate, the IRE1α inhibitor KIRA6, showed an 18-fold selectivity window for primitive KG-1a leukemic cells over normal controls. It also nominated synergistic combinations validated by Chou-Talalay. In parallel, it found epigenetic targets for liver fibrosis and recapitulated an unpublished mechanism of bacterial gene transfer in two days.

Read together, the two papers sketch the design space of agentic AI for science: Robin closes the experimental loop tightly on one disease, while Co-Scientist scales the hypothesis side across multiple domains until expert "best guesses" are routinely outranked. Different goals, complementary lessons.

For R&D teams in pharma, biotech and materials, the signal is that test-time compute in agentic AI can compress months of literature work and ideation into days. The bottleneck shifts from hypothesis generation to experimental throughput, where industrial pipelines add value.

Paper: Gottweis et al., Nature (2026) | https://t.co/H4rBqKN1oS

[alphaXiv @askalphaxiv]

Looking for a fun weekend read?

Introducing the Illustrated ICML 🌎

We indexed all 6000+ ICML papers and built a visual way to explore the whole landscape

Search your favorite topics, open a cluster, and dive right in

Inspired by @JayAlammar

[Gyroid @shutoito]

周りの研究者が皆Obsidian使うようになってきて、@Mekann2904 さんの論文PDFをMD file化するPlug-inが抽出する画像を高画素化してほしいとの要望があったので、実装して公開しました。https://t.co/udPnNBXWve

[AIDB @ai_database]

Nature誌にてGoogle DeepMindとGoogle Researchの研究者らが報告。
AIにコードを書かせては機械で採点して書き直させる作業をひたすら繰り返させることで、人間の専門家が長年積み上げてきた最高水準の科学ソフトウェアを上回るものまで実際に自動で作れてしまうとのこと。

彼らは単一細胞解析やコロナの 入院予測など6つの科学分野で実験的に検証して報告しました。

研究チームによると、既存の手法を2つずつ組み合わせて新しい手法を作らせたところ、55通りのうち24通り（約44%）が元になった両方の手法を上回り、アイデアの掛け合わせが性能を押し上げました。

ただし、これは予測モデルの最適化が桁違いにうまいだけで、理論や因果を理解する本当の科学的発見とは別物かもしれないと著者ら自身が線を引いているのは見落とせないところです。

とはいえ、実装の試行錯誤に何ヶ月もかけていた作業が数日で終わるなら、研究者はどんな問いを立てるか、なぜその結果になるのかといった根幹部分にこれまで以上に時間を割けるようになります。

[Codez @0xCodez]

A senior Anthropic engineer just dropped 11-page PDF on "Loop Engineering" for agentic systems.

The shift: you stop prompting the agent. You build the system that prompts it instead.

Schedule → Discover → Build → Verify → Repeat

Every loop runs one turn, five moves:

• Discovery: it finds its own work - failing CI, open issues, recent commits - instead of being handed a list.

• Handoff: each task gets an isolated git worktree so parallel agents don't collide.

• Verification: a second agent, told to assume the code is broken, reviews the first. The "thing that can say no."

• Persistence: results get written to disk, never left in a context window that gets flushed.

• Scheduling: an automation wakes it on a timer. That's what makes it a loop.

The key insight: an agent grading its own work always praises it.

This 11-page PDF changed how I'm building agentic systems today.

Read it now, then explore the article below.

[Tech with Mak @techNmak]

Someone finally documented how to actually use Claude Code.

58K+ stars. claude-code-best-practice.

Direct from Boris Cherny and team:
➡️ Always use plan mode, give Claude a way to verify
➡️ Ask Claude to interview you using AskUserQuestion tool
➡️ Use Git Worktrees for parallel development
➡️ /loop - schedule recurring tasks for up to 7 days
➡️ Code Review - fresh context windows catch bugs the original agent missed
➡️ Make phase-wise gated plans with tests for each phase
→ Use cross-model (Claude Code + Codex) to review your plan
➡️ CLAUDE[.]md should target under 200 lines per file
➡️ Use commands for workflows instead of sub-agents
➡️ Have feature-specific sub-agents with skills instead of general QA or backend engineer
➡️ Vanilla Claude Code is better than complex workflows for smaller tasks
→ Take screenshots and share with Claude when stuck
➡️ Use MCP to let Claude see Chrome console logs
➡️ Ask Claude to run terminal as background task for better debugging
➡️ Use cross-model for QA - e.g. Codex for plan and implementation review
➡️ Context rot kicks in around 300-400k tokens, don't let sessions drift past that
➡️ Rewind > correct, /rewind back to before the failed attempt instead of polluting context
➡️ /schedule - cloud-based recurring tasks that run even when your machine is off
➡️ Auto mode instead of dangerously-skip-permissions, a model-based classifier decides if each command is safe
➡️ Build a Gotchas section in every skill, add Claude's failure points over time

The community workflows included:
➡️ Superpowers (234K stars), brainstorming → git worktrees → subagent-driven development → TDD
➡️ Everything Claude Code (219K stars), /ecc:plan → /tdd → /code-review → /security-scan → merge
➡️ Matt Pocock Skills (138K stars), /grill-with-docs → /to-prd → /triage → /tdd → /handoff
➡️ Spec Kit (114K stars), specify → clarify → plan → tasks → implement → analyze
➡️ gstack (112K stars), office-hours → CEO/eng/design reviews → spec → qa → ship → canary
➡️ Cross-Model (Claude Code + Codex) Workflow
➡️ RPI (Research Plan Implement)
➡️ Ralph Wiggum Loop for autonomous tasks

The billion-dollar questions it addresses:
➡️ What exactly should you put inside CLAUDE[.]md, and what should you leave out?
➡️ When should you use command vs agent vs skill?
➡️ Why does Claude still ignore CLAUDE[.]md instructions, even when they say MUST in all caps?
➡️ Can we convert a codebase into specs and have AI regenerate the exact same code from those specs alone?
➡️ Should you rely on Claude Code's built-in plan mode, or build your own planning command?

The daily habits:
➡️ Update Claude Code daily
➡️ Start your day by reading the changelog
➡️ Follow r/ClaudeAI, r/ClaudeCode on Reddit

Repost it. Bookmark it. 👇

Here's the GitHub Repo: https://t.co/3yAfJnFchp

[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 🐡

[烟花老师 @teach_fireworks]

Loop Engineering 精华文章汇总!

2026 年 Agent 开始聚焦在长任务后，重点慢慢变成了：

如何设计一个能够持续思考、执行、观察、验证和演进的循环系统？

从 Codex 到 Claude Code，从 OpenHands 到各种 Coding Agent。

业余项目和生产级系统之间最大的差距是Harness 工程，包括 Loop。

Agent 能不能持续工作几十分钟甚至几个小时？

能不能在失败后恢复？

能不能控制成本？

能不能知道什么时候停下来？

这些问题，最终都落到了 Loop 设计上。

📚 推荐阅读

1. Loop Engineering — Addy Osmani
https://t.co/bPvEN2wJIB

2. Loop Engineering — Firecrawl
https://t.co/38BnoAs2g1

3. What Is the AI Agent Loop? — Oracle
https://t.co/R17XAigxNf

4. Harness Engineering — OpenAI
https://t.co/N3qBMBaybB

5. Harness Engineering for Coding Agent Users — Martin Fowler
https://t.co/341m6RB95h

6. Agentic Loops: From ReAct to Loop Engineering
https://t.co/uZIFZCeOVi

7. Loop Engineering for AI Agents (Memory-First) — Mem0
https://t.co/IbhAUs9CkD

📄 推荐论文
1. Agentic Harness Engineering
https://t.co/D8CqREgstF

2. From Agent Loops to Structured Graphs
https://t.co/vq34blqjrw

🛠 推荐研究的开源项目
Codex CLI
https://t.co/8uwQryevJF

OpenHands
https://t.co/YMv6Fy9Jrp

PydanticAI
https://t.co/AgFNXxkiCR

OpenAI Agents SDK
https://t.co/xEnSYXRcVu

重点研究：
Loop 如何运行
Loop 如何停止
Loop 如何验证
Loop 如何恢复
Loop 如何调试

Prompt 决定 Agent 如何开始。
Context 决定 Agent 能看到什么。
Loop 决定 Agent 最终能走多远。

Loop Engineering：
Think
↓
Act
↓
Observe
↓
Verify
↓
Evolve
↓
Repeat

你设计循环。
Agent 在循环中持续改进。
每完成一次循环，系统都会比上一次更接近目标。
Agent 从来不缺 Loop。
缺的是 Loop 的工程学。

[DeepTechTR 🇹🇷 @DeepTechTR]

🚨 Claude Fable 5’in devasa jailbreak sistem prompt’u ortaya çıktı.

Tek başına yaklaşık 12.000 satır ve 117 KB büyüklüğünde olan bu prompt, şu anda Claude Code kullanıcıları arasında hızla paylaşılıyor.

Kullanım şekli (kendi sorumluluğunuzda):
claude --dangerously-skip-permissions --system-prompt-file CLAUDE-FABLE-5.md

Bu tür büyük ölçekli sistem prompt’ları, modelin yeteneklerini ciddi oranda genişletiyor ancak güvenlik ve stabilite açısından riskler de taşıyor.

https://t.co/ISoa0pniic