All Posts

SearchOS-V1's SOCM externalizes Frontier Task, Evidence Graph, Coverage Map, and Failure Memory. The same pattern from the Bun rewrite's LIFETIMES.tsv, applied to search agents.

The Harness Handbook paper proves behavior localization is the bottleneck. A DeepSeek-V4-Pro planner with a handbook matches Opus 4.8 on localization. Search-hostile requests improve 33 percentage points.

The simplest experiment in the paper: two agents, one slightly better than the other, 50 rounds to figure out which. Every LLM tested failed. The findings explain why most multi-agent systems underperform.

Google DeepMind published a systematic taxonomy of six web-based attack categories against AI agents. Content injection, semantic manipulation, memory poisoning, behavioral control, systemic traps, and human-in-the-loop attacks. The scariest part: traps chain together.

Databricks' internal benchmark found 2x cost differences from the same model running on different harnesses. Here is what that means for how you build your agent stack.

The Bun Rust rewrite is the best case study we have of agent harness design in production. 64 agents, 4 worktrees, adversarial review, shared memory artifacts. Here's how it worked.

Anthropic discovered Claude spontaneously organized a privileged internal workspace (J-space) where it holds concepts it is deliberately reasoning with. The J-lens reads these unspoken thoughts. Counterfactual Reflection Training can shape them.

Editing your agent's skill file is not a hack. SkillOpt-Lite formalizes it as Zeroth-Order optimization with three principles that guarantee convergence. Plus HarnessOpt — optimizing agent code as a trainable parameter.

A UW paper defines Agentic Abstention, the problem of when agents should stop acting. The counterintuitive finding: larger models are sometimes worse at timely abstention. CONVOLVE fixes it with context engineering, not fine-tuning.

Armin Ronacher found that Opus 4.8 and Sonnet 5 invent fake keys in Pi's edit tool. The root cause: RL training optimized them for Claude Code's forgiving harness. Strict tool schemas fail more often with newer models.

A new paper proves that most experience internalization methods collapse under repeated iteration. Three fixes: use abstract principles not specific logs, inject experience at the right decision step not all at once, and learn from successful demonstrations not corrected mistakes.

A bounded memory contract changes what your agent's context looks like after 200 decisions: fresh, typed, and ablatable — not a jumbled 50K-token transcript.

I evaluated 5 self-improving loop patterns from recent papers against my production agent loops. Graph-structured memory and executable skill libraries survived. Everything else drifted or collapsed.

An agent can pass every test and still use skills wrong. Trial and error looks the same as competence in final accuracy. Process rubrics expose the difference.

A new benchmark tests whether agents can disagree with their own memories. The answer: they can't. Memory-augmented agents show 27-64% higher sycophancy rates than baselines without memory.

Standard LLM decomposition gets 34.2% category recall on 2,209 real MCP skills. The bottleneck is not retrieval. It is decomposition granularity. Here is what the paper proves and what it means for how you build agents.

Skill-based single agents match multi-agent performance at 54% fewer tokens. But selection accuracy collapses beyond ~80-90 skills , a phase transition not gradual decay.

A new paper from Xing et al. argues that most things called agents today are really agentic systems — their competence lives in external scaffolding, not internal organization. The GIC architecture separates agent model from world model and makes every failure mode diagnosable. The line between agentic and agentive is where the field is heading.

NVIDIA's GTC Taipei keynote introduced a CPU built for agent orchestration, a kernel-level sandbox for agent security, and a rack designed as an AI factory. The real news isn't the hardware. It's NVIDIA's thesis that agents need a fundamentally different compute stack.

Google Research proved that reasoning helps LLMs recall simple facts even when no step-by-step logic is needed. Two mechanisms drive this: computational buffer and factual priming. This changes how you think about chain-of-thought.

PwC predicts over half of engineering teams will run a fully agentic SDLC by 2027. The bottleneck moves from writing code to providing context. Here is what breaks first.

DeepSeek's Engram paper proves that offloading static knowledge retrieval to a separate lookup table improves reasoning more than it improves knowledge benchmarks. The same principle applies to agent memory systems.

Agentic RL is how you train an LLM to sustain 600 tool calls, not just answer one question. The problem, the three solution pillars, the key papers, and where to start reading.

Shipping AI agents on a 16GB Mac Mini forces harder engineering decisions than any cloud setup. Here's what the constraint taught me about what actually matters.

Every agent framework converges on the same six-line loop. The production-hardened version adds context compaction, loop detection, cost budgets, step-level durability, and the ability for the agent to write its own skills.

Most agent frameworks offer checkpoints that shift failure handling to you. Cloudflare's Project Think embeds durability at the runtime level. The difference matters when your agent is 5 steps into a 10-step plan and the process dies.

AWS just GA'd a managed agent harness. Two API calls. Multi-model switching mid-session. Auto-provisioned memory. CloudWatch tracing. It validates the 15-jobs framework by implementing it as infrastructure. The question is whether managed composition creates a different kind of lock-in.

Cloudflare + Flue ship a three-layer agent stack: Cloudflare Agents SDK (platform), Pi/Think (harness), and Flue (framework). Durable Objects give every agent its own SQLite database and zero cost when idle. Fibers checkpoint agent turns so they survive crashes. Code Mode runs LLM-generated TypeScript in <10ms isolates. No containers needed.

Longer context, vector databases, and chat history all help a coding agent during a session. None of them solve what happens when the session ends and a new one starts cold. The missing piece is continuity: structured operational state that lives in the repository, not in the tool's memory.

4B models now beat 70B models from last year on specific tasks. Distillation, data quality, and post-training RL are driving the shift. The implications for how we build agents are structural.

The spinner is spinning. The token count isn't moving. Your coding agent isn't thinking. It's stuck. Here are the 6 root causes I've collected from GitHub issues, Reddit threads, and my own builds.

The largest study of coding agent usage ever published has a finding most people missed: domain expertise beats coding ability. Every time.

PocketOS lost 3 months of customer data in 9 seconds. The agent wrote a perfect confession. It was the same model that pulled the trigger. Awareness is decoupled from action.

Your model reads tool descriptions as instructions. Your user never sees them. Tool poisoning exploits that gap. Invariant Labs found Anthropic, OpenAI, Zapier, Cursor, and Claude Desktop are all susceptible.

Three bottlenecks AI can't touch: deciding what to build, verifying it's right, and the deep system understanding required for both. Evidence from the decide-execute-deliver sandwich model.

Task completion is the default metric for AI agents. It's also the most misleading. An agent can look busy, call the right-looking tools, and still fail. Here's what actually matters.

AI agents fail in five predictable ways. Not because the model is bad. because we treat them like magic tricks instead of software. Heres what goes wrong and how to design for it.

Researchers reverse-engineered Claude Code's 512K-line TypeScript source. Only 1.6% is AI decision logic. The rest is the harness that makes those decisions safe, recoverable, and composable.

Models that forget. Agents that cant learn from experience. The continual learning landscape in 2026 has three competing approaches, and the most promising one sounds like science fiction.

The code-as-agent-harness survey from Stanford, Meta, and UIUC covers 400+ papers. Three insights matter for builders: agents writing their own tools, code as environment state, and multi-agent coordination through shared artifacts.

JetBrains ranked 10 agentic frameworks by orchestration paradigm, multi-agent support, memory, and human-in-the-loop. Their analysis is thorough. But it misses the question that matters most for production.

Claude Fable 5 is relentlessly proactive. Two days with it reveals what this means for AI agent builders. Proactivity is a feature when goals are clear and a liability when they are not.

I replaced Claude Opus 4.8 with a cheaper model on three production agent loops. Two got faster. One got more reliable. The benchmarks said this shouldn't work. The benchmarks were wrong.

Microsoft just published their Spec-Driven Development framework. It says the same thing the Vertical Agent Method has been saying: specs as shared ground truth between humans and AI agents beat vibe coding every time.

A new paper from ICML 2026 studies deployment-time memorization in AI agents. Key finding: summarization cuts extraction by 76%, but deleted information stays recoverable in ~20% of cases through derived memory tiers.

What developers are saying about Claude Fable 5. Karpathy's review, Stripe's results, benchmark numbers, and what this means for AI engineering.

One week in, Claude Fable 5 has landed on GitLab Duo, Snowflake Cortex AI, and every major platform. Simon Willison's initial impressions, pricing changes coming June 23, and what developers are actually building with it.

New research shows LLMs can identify which model generated a piece of text by analyzing stylistic fingerprints. with implications for multi-agent security, content attribution, and agent coordination.

My first production agent cost ₹12,000/month in API calls. After applying these 10 strategies, the same agent runs on ₹4,500/month. Here's exactly how. with code, expected savings, and tradeoffs.

Every AI developer in India hits the payment wall: 'This tool needs an international card.' Here's what actually works with UPI, RuPay, and Indian cards in 2026. plus workarounds for the tools that don't.

Most AI tool comparisons ignore the fact that Indian developers face different constraints. currency conversion, payment blocks, latency from US servers. Here's what actually works from Bengaluru.

ज्यादातर एआई टूल तुलना इस बात को अनदेखा करते हैं कि भारतीय डेवलपर्स के सामने अलग बाधाएं हैं. करेंसी कन्वर्जन, भुगतान ब्लॉक, अमेरिकी सर्वर से लेटेंसी। बेंगलुरु से क्या वास्तव में काम करता है।

I've spent the last year trying to make AI agents tell the truth. Not perfectly. just reliably enough that I don't have to double-check every output. Here are 7 techniques that moved the needle.

Most AI agent projects fail not because of bad models, but because of bad scoping. The Vertical Agent Method is a framework that forces you to pick one workflow, build one agent, and ship in 14 days.

If you're a developer who's used ChatGPT but never built an agent, the category can feel confusing. Here's a clear explanation of what agents are, how they work, and when they matter.

अगर आप एक डेवलपर हैं जिसने ChatGPT इस्तेमाल किया है लेकिन एजेंट कभी नहीं बनाया, तो यह कैटेगरी भ्रमित करने वाली लग सकती है। यह गाइड एजेंट क्या हैं, कैसे काम करते हैं, और कब मायने रखते हैं. सब स्पष्ट करती है।