Nov 13, 2026 · Fri · 10 items

Google releases Gemini 4 Hydrogen, Anthropic launches self-hosted Managed Agents, AgentCore's next-generation runtime becomes the default

Today's thread is how agents divide the work and where they run. Google fills in a cheap execution tier with Hydrogen so expensive models only make the calls, while Anthropic and AWS answer where agents run, where their data lives, and whether idle time is billed. On safety, IBM and Google attack prompt injection from training and from detection, but long-term memory remains a blind spot.

RSS
    • Flat pricing across the full 1M-token context: $1.50 per million input tokens and $7.50 per million output tokens. It is available across all tiers of AI Studio, the Gemini API, Gemini for business, the Gemini app and Google Search, and to paid AI Pro and Ultra subscribers in Antigravity.
    • At its default high thinking level it scores 51 on the Artificial Analysis Intelligence Index versus Argon's 50, reaching 54 at xhigh. Against Gemini 3.8 Flash it finishes tasks 2.5x faster, lifts Terminal-Bench 4.1 from 18.2% to 57%, and cuts fabricated claims by more than 5x.
    • A new Orchestrator in Antigravity switches between Carbon and Hydrogen within one session, reaching near-Carbon success on Terminal-Bench 4.0 while using 24% less quota on average and finishing 19% faster.
    • The same day Google Search moved to Hydrogen globally, which Google calls the biggest model upgrade to Search yet.

    Builder's takeOnce Carbon rises to $4 / $20 after 11-30, Hydrogen costs less than half of it, filling the bottom layer of expensive-model-decides, cheap-model-works. I would move PandaClaws' bulk rewriting and formatting calls to Hydrogen for a week and compare rework rates against the current model. The Orchestrator idea is worth copying: route by task difficulty, with clear triggers for moving up a tier.

    • You host the API, the agent loop, and storage for agents, sessions and session history; model requests go to the provider you choose, Anthropic by default.
    • Supported inference providers include Amazon Bedrock, Claude Models on Google Cloud (Google managed), Microsoft Foundry, or your own model gateway.
    • It exposes the same API as the hosted service, so the SDK and the ant CLI work against your server; the server never runs the agent's shell or file tools, which stay in sandboxes.
    • You run and secure the server, database and sandboxes and install each release yourself, and some features exist only on the hosted service. Access is by request through your Anthropic account team.

    Builder's takeThis is for customers whose session history cannot leave their cloud or data center, who until now had to build an agent loop from scratch. I would evaluate it first for the enterprise version of AI Cloud Drive: data stays on our side and model calls go through the customer's existing cloud account. But count the operating cost; if you only need tools to run on your own machines, self-hosted sandboxes are enough.

    • Sessions restore from a snapshot of the initialized agent and scale compute and memory with the work, up to 8 vCPU and 32 GB per session, with container images up to 10 GB; the AWS blog puts this at 4x the previous size and up to 15x faster starts.
    • Idle agents scale to zero and memory is reclaimed within minutes of release; always-on agents can use committed baseline pricing and burst up to 4x the baseline on demand.
    • New runtimes use it by default in 19 Regions. Existing runtimes stay put until you set platformVersion to V2 on create or update; V1 keeps a new runtime on the current version.
    • Customer figures: Mission saw 35% faster cold starts and 17% lower runtime cost per call; Zuora cut memory per invocation by about 60% in many use cases.

    Builder's takeRead with NVIDIA donating Agent Substrate on 11-10: not paying for idle time and restoring from snapshots in seconds is now table stakes for agent runtimes. Multi-turn sessions with long pauses, like AI Interview, benefit most. If you are on AgentCore, set one multi-turn agent to V2 and compare a week of billed memory and first-response latency before moving the rest.

    • LLMON uses six reserved special tokens as structural delimiters, making instructions, data and requirements separately addressable blocks; an exec block states which instruction runs on which data, and instructions not referenced by it are ignored.
    • IBM releases two experimental previews, granite-4.1-3b-LLMON-preview and granite-4.1-8b-LLMON-preview, plus a toolkit and lossless JSON-to-LLMON converters, and says general capability is on par with Granite 4.1 Instruct.
    • On the OPI indirect prompt injection benchmark it avoids 47% more attacks than the best frontier model tested and 95% more than the best open model, with similar trends on ASB and StruQ.
    • IBM says this is learned behavior, not an enforced guarantee, and targets static injections; adaptive attacks that unfold over many turns are still being worked on.

    Builder's takeAI Cloud Drive has models read whatever documents users upload, so indirect injection is unavoidable. Small models are already good enough for read-and-extract steps, so I would run the 8B preview on our internal extraction set and measure both injection blocking and extraction accuracy. It is a preview, though; it does not replace least-privilege tools and an outbound allowlist.

    • The test used five public benchmarks, AgentDojo, InjecAgent, Agent Security Bench, AgentDyn and AgentHarm, 1,774 sessions in all, with an ADK agent on gemini-2.5-flash and each benchmark's deterministic check labeling the outcome.
    • Of harmful instructions the agent read and carried out, 87% were flagged: 85% on AgentDojo, 87% on InjecAgent, 99% on AgentDyn and 81% on AgentHarm.
    • False alarms ran 2% to 4% on benign office sessions and 16% on AgentHarm, whose benign tasks also post to social media, run terminal commands and download files.
    • The clear gap is memory poisoning: when instructions planted in long-term memory made the agent act, it caught 4 of 18.

    Builder's takeA vendor testing on someone else's benchmarks and publishing the weak spots is worth copying. For product teams the takeaway is that after-the-fact detection catches most injections but long-term memory is a blind spot: agents like PandaClaws that remember user preferences need a separate check before anything is written to memory, with a traceable source for each write.

    • Go's SSA prove pass first removes bounds checks it can prove safe; only the surviving runtime.panicBounds traps, with the disassembly, go to Argon, which writes a Z3 script for each.
    • When Z3 returns sat it yields concrete input bytes that go test replays; any panic is a real bug regardless of whether the model's encoding was sound. An unsat result only means maybe correct.
    • It takes about a minute per function, dominated by Argon's translation, with Z3 itself finishing in milliseconds; it found three latent bugs in skill-lint.
    • Unseeded go test -fuzz missed two of the three planted crashes across repeated 60-second runs.

    Builder's takeThe appeal is that every finding is real, so false positives cost almost nothing, which makes it a good CI complement to fuzzing. Our upload and parsing services in Go are exactly where these bounds bugs live; I would start with a few parser functions, aiming not for proofs but only for real, reproducible crashes.

    • V4-Pro has 1.6T total parameters with 49B active per token, aimed at complex reasoning and high-quality generation.
    • V4-Flash has 284B total parameters with 13B active per token, aimed at latency- and cost-sensitive production.
    • V4.1-Flash uses a Causal Encoder-Decoder (CED) architecture on a 552B backbone, activating 8B in prefill and 16B in decode, with native multimodality and up to 384K output tokens; CSA2 attention and FP4 KV caching cut the global KV cache to about a quarter of V4-Flash's.
    • All three support a 1M-token context and deploy from the SageMaker console or Python SDK.

    Builder's takeFor teams whose data must stay in their own cloud account but who want cheap open models, this removes the step of building inference yourself. I would look first at V4.1-Flash: a KV cache a quarter the size matters most for long-context agent work. Before going live, compare per-task cost between on-demand Bedrock and an always-on JumpStart endpoint on your own workload; with uneven traffic the endpoint may not pay off.

    • It is an out-of-tree plugin selected with SGLANG_PLATFORM=neuron; SGLang core still handles the API server, request lifecycle and RadixAttention prefix caching.
    • The plugin runs on native PyTorch with NKI kernels compiled through torch.compile, and implements the Trainium-specific models, attention, MoE and graph runner.
    • It supports prefill-decode disaggregation, with the prefill server sending the KV cache to the decode server via NIXL over EFA.
    • It ships as an AWS Deep Learning Container; the walkthrough serves gpt-oss-120b on a Trainium3 instance.

    Builder's takeThe biggest cost of switching chips is switching the inference stack; SGLang users can now try Trainium without changing how they call it. If you self-host open models, run one current model with the same load on Trainium and on GPUs and compare cost per million tokens. Check the list of validated models first and keep anything off that list out of production for now.

    • Codex still runs on the developer's workstation, sending inference to supported OpenAI models through Bedrock; the examples use GPT-5.6 Sol, and Sol, Terra and Luna each need checking per account, Region and inference path.
    • Three paths: Native AWS Access (the recommended starting point), AgentCore Gateway (managed routing and Bedrock Guardrails), or your own LLM gateway (controls in the request path).
    • Identity flows from the existing IdP via SAML and SCIM into IAM Identity Center, which issues temporary credentials to Codex; the provider setting lives in user-level or managed config so a repository cannot change it.
    • The open-source Guidance for Codex on AWS repository has quick starts for LiteLLM, Portkey, ADOT and CloudWatch.

    Builder's takeRead with ChatGPT Enterprise arriving in AWS Marketplace on 11-09: OpenAI's enterprise products are moving into AWS billing and identity as a whole. If you already buy through AWS, follow the guide with five people on Native AWS Access for two weeks, attribute usage to each IAM identity, then decide whether you need a gateway.

    • Bedrock records the IAM user or role for every inference request automatically, with no change to your calls.
    • With one role per person, use principal tags on the role; for shared roles or a gateway, pass session tags at AssumeRole to tell users apart.
    • Activate the tags as cost allocation tags, then view spend by identity in Cost Explorer or a CUR 2.0 export.
    • Create an AWS Budget for Bedrock filtered to one identity or tag, with a budget action that attaches a Deny policy when the threshold is crossed.

    Builder's takeThis pairs with the Codex item above: before opening coding tools to more people, see each person's spend and cap it. We would do the same for internal model access, with a session tag per person and the budget action set to alert plus manual approval at first, switching to automatic deny once it is stable so running tasks aren't cut off at month end.

Researched and drafted with AI assistance; editorial standards and views set by Darius.

Every Monday, the week in AI in one email

Every Monday morning: the 6 AI stories that mattered most in the past seven days, with my take, in your inbox.

Your email is only used to send the weekly and is never shared. Every email has a one-click unsubscribe link. See the latest issue →