This week, the agents learned to sleep, and Postgres learned to clean up after itself without locking the house. Anthropic publishes a blueprint for always-on agents that, underneath the buzzword, turns out to be an inbox table, a timer table and an outbox table. Meanwhile, Claude Code gets an experimental Code Mode where Claude stops asking for tools one at a time and writes JavaScript to call them instead.

On the database side, PostgreSQL 19 lands with REPACK (CONCURRENTLY), plan advice, and “read-your-writes” on standbys, and Google DeepMind releases Gemini 4 Neon, which claims the top spot on the AA Coding Agent Index. Grab a coffee (I need several after yesterday), and let’s dive in. The WIND section at the end is written by a tired but very happy event organiser.


Databases

  • PostgreSQL 19 Released!. This post by the PostgreSQL Global Development Group announces PostgreSQL 19, and as a database person, I read the release notes twice. The headline feature is the new REPACK command, which reclaims bloat and can reorder a table to match an index, and with REPACK (CONCURRENTLY), it does so without blocking reads or writes. It replaces VACUUM FULL and CLUSTER (both kept for compatibility), which anyone who has scheduled a 2 AM maintenance window will appreciate. The other big one is the pg_plan_advice extension, which lets you stabilise plan choices and experiment with alternatives via a “plan advice” mini-language, while its companion pg_stash_advice stores advice and applies it automatically by query identifier, so you can fix a slow plan without touching application code. Autovacuum also gets parallel index vacuuming, a new scoring system to prioritise tables, and a pg_stat_autovacuum_scores view to show its reasoning.

    For distributed setups, logical replication no longer needs a server restart: creating the first logical replication slot automatically raises the effective WAL level. Sequences can now be replicated (FOR ALL SEQUENCES), CREATE PUBLICATION gets an EXCEPT clause, and subscriptions can take connection settings from a foreign server. Applications reading from standbys get “read-your-writes” consistency with the new WAIT FOR LSN command, and postgres_fdw can import remote table statistics on ANALYSE for better plans.

    Developers get plenty of goodies too. INSERT ... ON CONFLICT DO SELECT handles the classic “get or create” pattern in one round trip, COPY can output JSON, the SQL/JSON path language gains string methods, window functions like lead(), lag() and first_value() support IGNORE NULLS, and random() can generate dates and timestamps. Performance work includes foreign key checks that make bulk inserts nearly 2x faster, NOT IN converted to anti-joins when NULLs are absent, and eager aggregation before joins. Also worth noting: JIT is now off by default, LZ4 becomes the default TOAST compression, MD5 authentication now warns, and RADIUS support is gone.

    What I find most interesting is the theme running through this release: control without disruption. REPACK (CONCURRENTLY), restart-free logical replication, and plan advice all focus on running mission-critical workloads without taking them down. And pg_plan_advice is essentially Postgres finally offering a sanctioned form of query hints, something SQL Server folks (hello, Query Store plan forcing) have had for years and the Postgres community debated for even longer. Given that last week’s roundup featured 1,000 agents coordinating through Postgres tables, a database that can tune itself without downtime feels very well timed. Which feature will you try first?


Generative AI

  • Google DeepMind Releases Gemini 4 Neon: 1M Context, #1 on AA Coding Agent Index. In this post by Asif Razzaq, we get the rundown of Gemini 4 Neon, Google DeepMind’s new reasoning model that sits between Gemini 4 Carbon (the heavy lifter for long-horizon projects) and Gemini 4 Hydrogen (fast, everyday execution). Neon targets coding agents, knowledge work and science workflows, with a 1M-token context window, 64K default output (up to 1M via background long decode), and pricing at $3 per million input tokens and $15 per million output tokens. It is closed-weight and Google-hosted only, available via the Gemini API, AI Studio, Vertex, Antigravity and the Gemini app. Inside agent workflows, it supports context compaction, multiple thinking levels (High by default, xhigh for the hardest work), and can act as an orchestrator in Antigravity, directing parallel Hydrogen subagents.

    The benchmarks, all self-reported by Google, are strong: 61 on the AA Intelligence Index (ahead of Claude Opus 5.5 at 59 and GPT-6.2 Sol at 57), #1 on the AA Coding Agent Index at 58.6, and a striking 95.2% on GraphWalks long-context recall versus 66.8% for Opus 5.5. It does not win every row, though: Opus 5.5 still leads on Terminal-bench 4.1 (65.8% vs 65.2%) and FrontierCode 2.0 (47.3% vs 46.2%). Google also argues that the real story is cost per task rather than per token, claiming 50–80% lower cost per task than rivals on Vals Index and Agent Arena, even though Neon is pricier per token than GPT-6.2 Sol.

    The “orchestrator plus cheap subagents” pattern is now clearly the industry default, whether it is Fable 5.2 directing a thousand agents or Neon directing Hydrogen. The frontier race has become less about who has the smartest single model and more about who has the best-priced team. I will wait for independent numbers before getting too excited, but competition at the $3/$15 price point is good news for all of us paying the bills.


  • Run tool calls from code with Code Mode. In this post, the Claude Code docs introduce Code Mode, an experimental (and off-by-default) feature that changes how Claude uses its tools. Normally, Claude asks for a tool call such as Bash, Read or Edit, reads the result, and decides what to do next. In Code Mode, Claude instead writes a piece of JavaScript that makes the tool calls, and Claude Code runs that code in your session. One piece of code can run commands in parallel, feed one result into the next call, and return only the part of the output Claude needs to read. The docs suggest it for repetitive changes across many files, searches that need filtering before Claude reads them, and several independent commands that can run at once. You turn it on with CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 (v2.1.323 or later), and it works with Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.2 in an interactive terminal session.

    The permissions model is where the interesting design decisions live. Each tool call in the code still goes through your deny and ask rules and your hooks under the tool’s usual name. Still, in auto mode, the classifier reviews the code before it runs, not each individual tool call, so it does not see values computed at runtime, such as a path taken from search output. The code runs through a tool called REPL, so you can add an ask rule for REPL to approve every piece of code first, write a PreToolUse hook that inspects tool_input.code, or use a PostToolUse hook to redact what the code returns before Claude reads it. Code waits up to ten minutes in the foreground, or runs for up to two hours in the background in auto or bypassPermissions mode.

    There is a fair list of limitations: no Remote Control, Claude in Chrome or computer use, no VS Code panel, Desktop app or cloud sessions, no gateways or Bedrock/Vertex/Foundry routing, and you can only resume a Code Mode session with Code Mode on. It is very much an early-adopter feature.

    Here’s what strikes me: this is the “let the model write code to orchestrate tools” idea that has been floating around the agent community for a while, now shipping inside Claude Code. It should mean fewer round trips, less context spent on intermediate output, and noticeably faster multi-step tasks. But it also shifts the security boundary from “review each action” to “review a program”, and the docs are refreshingly honest that a classifier reviewing code cannot see runtime values. If you rely on permission rules for anything important, read the hooks section carefully before flipping the switch. I am definitely trying this on my Event Management System codebase, but with a REPL ask rule in place, at least to begin with.


  • Building always-on agents. William Hu looks at what it takes to build always-on agents: agents that are stateful and proactive, managing context across sessions and taking actions without direct supervision. The first insight is that “always on” is a user-experience description, not reality. The agent actually spends most of its time asleep, waking up for a run: it receives an event, does its work inside a session, saves what happened, and goes back to sleep. Hu credits better model judgment and cheaper intelligence for the resurgence, noting that on one long-horizon coding benchmark, Opus 5.5 cost 78% less per solved task than Opus 5.

    The architecture is built from five primitives. An event inbox, usually a database table plus an HTTP handler and a single worker, so concurrent events don’t start competing runs and a crash doesn’t lose an event; the handler acknowledges quickly, the inbox is the source of truth, and pending events are batched. Timers, in their own table, split into follow-ups (deadlines the agent sets for itself) and schedules (recurring tasks), with a scheduler polling for what is due and dropping events into the inbox. Memory, as a directory of files backed by durable storage, holding only what the agent cannot look up again: user instructions, user notes, past messages so nothing is repeated, and per-task progress files, with an index loaded at the start of each run and, optionally, dreaming to curate it (see the agent memory post from last week).

    The last two primitives carry the risk and the polish. Permissions combine a credential proxy outside the agent’s environment that injects real credentials, auto mode classifiers for higher-risk actions, and deferred tool calls, where the run ends mid-call, the request goes to the user, and their answer arrives as a new inbox event that resumes the saved session. The outbox is a table of outgoing messages with a dispatcher, and Hu’s advice on tuning it is gold: an agent that sends too much is noise, one that sends too little misses things, so build evals, and let the agent start quiet and earn more of the user’s attention over time.

    What fascinates me is how unglamorous the blueprint is, and I mean that as the highest compliment. Strip away the AI, and you have the transactional inbox/outbox pattern, a job scheduler, and a single-consumer work queue: things data engineers have built on relational databases for decades. Once again, the “new” agent infrastructure is a handful of well-designed tables. I keep wrestling with the outbox advice, though, because “start quiet” is easy to say and hard to measure. How do you build an eval for “the user wanted to know this”? That, more than any of the plumbing, feels like the real frontier for proactive agents.


WIND (What Is Niels Doing)

It is Sunday morning, and yesterday was Data & AI Community Day Durban: Encore / .NET Conf 2026 Community Edition South Africa. Close to 200 people came through the doors at Richfield College’s Umhlanga Campus, and while I have only just started collating the stats, everything points to another very successful event. A huge thank you to the speakers, sponsors, volunteers and, of course, everyone who gave up a Saturday to attend. Besides organising, I was part of the .NET Conf keynote and also delivered a talk towards the end of the day, so it was a full one!

Now it is time to recharge the batteries, but not for long. On Wednesday, I am off to Johannesburg to speak at .NET Conf Africa, and on Saturday I’m heading to Cape Town for the Cape Town leg of .NET Conf 2026 Community Edition South Africa. If you are in either city, come and say hello.


~ Finally

That’s all for this week. I hope you find this information valuable. Please share your thoughts and ideas on this post, or ping me with suggestions for future topics. Your input is highly valued and can help shape our discussions.

I look forward to hearing from you.