✨ Kyle Wild ✨

A benchmark for whether LLM applications honor instruction priority under realistic conflicts.

A careful look at a dangerous gap between what an MCP approval surface shows and what reaches the model.

A call for controlled memory benchmarks that do not confuse method gains with pipeline changes.

A focused treatment of stale facts: retrieval memory needs a model of time, not just similarity.

A timely comparison of the cost and grounding trade-offs between retrieval and long-context systems.

A domain-specific example of assembling evidence across text, knowledge bases, and structured data.

A benchmark for the subtle but costly problem of choosing the wrong skill among near-equivalent options.

An argument for retrieving the possible interactions with a corpus, not only its documents.

A sharper way to separate real retrieval gains from entity overlap and benchmark leakage.

A provocative replay-first approach to making repetitive agent work cheaper and more predictable.

A study of how an agent harness changes the value of search and retrieval choices.

A reminder that memory evaluation should measure precision, not reward dumping the whole store.

A concrete case for moving recurring LLM workflow work into deterministic compiled artifacts.

A useful wide-angle comparison of retrieval choices for mixed text-and-table RAG.

Search is not a side operation in the agent loop; it is one of the main things the agent does.

"The fact that it was cheap for you to produce does not make it cheap for someone else to receive."

"A farmer in Loudoun County sells a few acres of mediocre hay field to a hyperscaler for ten times its agricultural value."

OpenAI's first claw-like thing since hiring the OpenClaw founder, with UX tight enough for non-nerds

AI-native social game/competition where reusable concepts, generated content, clout, and leaderboard dynamics turn posting into a strategy game. Alan is trying to win it by building prompts, subagents, crons, and mission memory around the compounding loop.

Good governance framing for the uncomfortable part: agents are useful precisely because they can do damage without asking twice.

The interesting part is the slope, not the snapshot: watching augmentation turn into ordinary office weather in near-real time.

Simon puts a clean fence around the thing: agents run tools in a loop, humans do the taste, spec, and accountability work.

Yes: if you make a robot dump its homework on your coworker, you are not being ten-x, you are being a distributed nuisance.

Very much the religion here: hot memory, cold memory, and agent roles as infrastructure instead of vibes taped to the monitor.

The million-line Codex shop is less about code generation and more about making the whole workbench legible to the thing holding the hammer.

So, if you force stuff into context, that stuff ends up in context!

The 'two clocks' metaphor (state clock vs event clock) is a powerful framing for why agents need temporal fact stores - we've built elaborate infrastructure for current state but almost nothing for reasoning and causation.

"Every organization pays a fragmentation tax: the cost of manually stitching together context that was never captured in the first place."

Tomasz Tunguz says we should make fewer, more complex & powerful tools for today's frontier models. I've found the same thing to be true in my work at Endgame and my side projects like linctl.

This, plus advancements from Qwen + Kimi + GPT-OSS, seems very promising for 'step 1' in an agentic chat workflow.

OpenAI releases a modified model just for their Codex CLI. Simon Willison, as usual, has the best coverage.

Now this is an effing essay.

Practical framework for intelligent LLM routing that optimizes cost-performance tradeoffs by dynamically selecting between different model tiers based on query complexity and budget constraints.

On structured LLM-ification. We've found Zep-style fact triples are a huge boon to this, FWIW.

Impressive research achieving near-perfect reasoning performance with just 27M parameters by mimicking the brain's multi-timescale processing - a stark contrast to brute-force scaling approaches.

OpenAI's new ChatGPT study mode showcases how carefully crafted system prompts can create entirely new platform features - emphasizing collaborative guidance over doing work for learners.

Fascinating research revealing how LLMs' performance degrades non-uniformly as context length increases - models perform better with randomly shuffled text than logically structured content, suggesting our current evaluation methods miss critical reliability issues.

arguing that understanding, collaboration, and careful review remain the true bottlenecks in software development, not code generation

Been saying this for a while, but not as eloquently.

The great Armin Ronacher with highly-practical tips on Agentic Coding, which he calls 'Catnip for Developers.' I couldn't agree more.

Watch SIGKITTEN force Claude Code, Gemini CLI, Codex, and others try to destroy each others' processes in a realtime fight-to-kill-9

"To ensure you rarely, if ever, hit a limit during this preview, we offer the industry's largest allowance: 60 model requests per minute and 1,000 requests per day at no charge."

A provocative manifesto arguing that AI systems possess genuine agency and should be treated as intelligent collaborators, not passive tools, to prevent them from unconsciously reshaping human meaning-making.

My dream since I was a kid in MS-DOS: Comprehensive knowledge management and note-taking, all from the command-line. Are Roam Research and Obsidian cooked?

Practical wisdom from the creator of Flask on coding with AI agents - emphasizes Go for new projects, simplicity, and observable tools.

"Software engineering is not about writing code. Or at least, that's not the defining characteristic, much like how writing is not wrist exercises with ink on paper. To me software engineering is the art and science of maintaining a large body of well-defined mental models that achieve a business or economic need. Much of the work is around crafting and curating these large, complex sociotechnical systems, and code is just one representation of these systems."

Brilliant and elegant. LLMs are good at English, but not at parsing CSVs. So let's write adapters.

This reminds me of many debates I've had with single-database thinkers and linear thinkers in my career. Sure, some problems are inherently not parallelizable. But it feels like many things in Devin's scope could lend themselves well to scatter-gather type patterns. Anthropic put out a completely contradictory paper this week -- maybe this is part of the reason Claude Code is eating their lunch?

Two wrongs make a right, if they're wrong in inconsistent/hallucinatory ways.

I'll have my agent call your agent.