OpenAI’s GPT-6.2 Astra and Sol launch drew some of the worst first impressions on record, yet the efficiency numbers tell a different story. NLW breaks down the benchmarks, the early tester backlash, and what the release says about OpenAI’s push toward cost-efficient enterprise work. In the headlines: the Nvidia board refusing to bring Jensen back, a wave of infrastructure outages, and strong Nvidia earnings.
What if your coding agent could test against AWS without an AWS account? No credentials, no bill, no waiting on a deployment. No guest this time. Romain goes through the launches from the past month that change how you build on AWS, starting with AWS Emulator, a local emulator that agents built and maintain on their own. Key topics covered: - AWS Emulator: a local emulator for the AWS CLI, SDKs and coding agents, how fidelity tests compare it with real AWS, and its limits (no IAM policy evaluation, single account) - How agents build and maintain the emulator, with an independent security agent reviewing every change - Amazon Bedrock AgentCore Runtime v2: sessions that start in under 2 seconds, up to 8 vCPUs and 30 GB of RAM, and idle agents that scale to zero - Kiro CLI 3.0: one agent harness across the CLI, IDE and web, workflows, cloud sessions and spec mode in the terminal - Bots in Kiro Crew: long-running agents that own one part of your process, with scoped permissions - AWS Step Functions workflows as agent tools, OAuth 2.0 token exchange in Amazon Cognito, and AWS Nitro sandboxes - The AWS Well-Architected Framework split into Cloud Foundations and Cloud Workloads, written so agents can run reviews - AWS Lambda Web Functions and AWS Continuum for Code Vulnerabilities Chapters: 00:00 AWS Emulator: test without an account 01:08 How the local emulator works 04:47 Fidelity, coverage, and developer reactions 07:14 Agents build and maintain the emulator 09:40 Faster, larger Bedrock AgentCore sessions 12:48 Kiro's new CLI, workflows, and bots 16:42 Connecting agents to AWS services 18:41 Well-Architected for agent reviews 21:30 Lambda Web Functions and vulnerability fixes 23:20 The feedback loop gets shorter
VS Code 1.147+ can now load agent skills straight from an MCP server! If your team runs an MCP server, you can ship skills from the same server as your tools, so every agent reads the same copy and gets updates the moment you deploy. Those skills can help models use your tools optimally and equip agents for the most common workflows.
Once agent skills are bundled inside the MCP server itself, the skills can be served with the same auth, access control, and trust model as the tools. One sign-in covers both, and each skill is versioned right alongside the tools it describes.
Skills-over-MCP: How it works
The MCP standard added support for skills in SEP-2640. Many thanks to the Skills Over MCP Working Group for getting it there! A server advertises that it can serve skills by declaring the extension in its capabilities:
The files themselves are ordinary skill:// resources that the client loads with resources/read as it needs them. So you get the same progressive disclosure you'd get from skills on disk, where the agent only pays for a skill when it uses one.
Adding skills to a FastMCP server
Adding skills to an existing MCP server is easy, especially if you are using the FastMCP framework for building your MCP servers.
In the example code below, we define a new Skill inline, with name, description, instructions, and files, and add that via the SkillCatalogProvider to the MCP server:
from fastmcp import FastMCP, Skill
from fastmcp.skills.provider import SkillCatalogProvider
release_notes = Skill(
name="release-notes",
description="Write release notes from merged pull requests.",
instructions="# Release notes\n\nGroup changes by theme. Follow template.md.\n",
files={"template.md": "## Highlights\n\n## Fixes\n"},
)
mcp = FastMCP("Team Skills")
mcp.add_provider(SkillCatalogProvider([release_notes]))
Learn more ways to add skills to FastMCP servers from their Skills over MCP documentation guide.
Using them in VS Code
Support for skills-over-MCP varies across MCP clients, as you can see from MCPJam's caniuse.dev compatibility matrix. VS Code is one of the first clients to add support, which makes it great for testing you MCP servers which bundle skills.
Verify that your VS Code is version 1.147 or higher, and has chat.agentHost.mcpSkills.enabled:
Run your server over HTTP:
fastmcp run server.py --transport http --port 8000
Start a new chat and type /. Your server's skills show up as slash commands, right next to the built-in ones.
Pick one and VS Code asks before it loads skills from that server. Then the agent follows the skill like any skill on disk, and pulls in template.md when the instructions point to it.
Of course, you don't need to explicitly invoke the skill. You can also write a prompt to the Copilot agent that causes it to invoke the bundled skill:
VS Code will prompt to ensure you want to allow the MCP server to load the skill instructions into the context, and you can decide whether to allow once or allow always. That prompt gives users more control over the instructions injected into their context windows.
Hosting MCP servers
A local MCP server works great if it's just for your personal workflows, but if you're like many developers, you're building MCP servers to share inside an organization or even externally for customers.
We have great ways for you to host MCP servers on Azure, like Azure Container Apps, Functions, App Service, or Kubernetes. Check our guide on choosing an Azure service for MCP servers.
The FastMCP team also makes it easy to deploy servers with their FastMCP Gateway, the quickest way to deploy a FastMCP server from a GitHub repo. For clients that aren't as far along as VS Code, the FastMCP Gateway can also offer your skills as plain tools, so the same URL works there too. They also offer FastMCP Skills Drop, a free page that turns your skills into an MCP server.
OpenJDK and Oracle disclosed Java4Shell (CVE-2026-114938) on November 17, and NGINX released fixes for two HTTP/2 flaws the next day. Docker began publishing fixed images for both in the Docker Hardened Images (DHI) catalog starting that same day.
What we know about Java4Shell is that it’s a memory-corruption bug in the Java runtime that can let an attacker with no credentials run code inside a Java application. Many container images contain a Java runtime, including application images that bundle their own, so it affects teams well beyond the ones that write Java.
Docker Hardened Images are the trusted foundation your applications should run on, because a flaw in the runtime inside an image is fixed only when that image is rebuilt, and Docker rebuilds its hardened images as soon as upstream fixes become available. Fixed images for the Amazon Corretto, SapMachine and Azul Zulu runtimes and for NGINX are in the catalog today, with Eclipse Temurin following as soon as Adoptium completes its fixed builds.
TL;DR
Affected: Java 17.0.6 and later, including Java 21, 25, 26 and 27, from every OpenJDK vendor.
Only on some hardware: the bug is reachable only when the JVM runs on an x86-64 CPU with AVX-512 VBMI. The same image can be exposed on one host and not on another.
Fixes are arriving vendor by vendor. Corretto, SapMachine and Zulu builds in DHI are fixed. Temurin, which many DHI application images use, is not released yet.
Check the version the runtime reports. A tag or a recent rebuild date does not tell you which Java build is inside an image. java -version does.
Until your image runs a fixed build, start Java with-XX:-UseBASE64Intrinsics. Set it yourself and check that it took effect. Make sure it reaches every JVM, not only the first one. The second half of this post shows how.
The NGINX HTTP/2 flaws are fixed in the catalog. The Docker Hardened Images for NGINX are rebuilt on NGINX 1.30.7 and 1.31.9. Pull the image again, or move a pinned tag to one of those versions, and redeploy.
What the vulnerability is
To decode Base64 quickly, the HotSpot JVM uses a hand-written routine built on AVX-512 instructions. That routine miscalculates a length when the input ends in unexpected padding and writes up to 62 bytes past the end of a buffer on the Java heap. Calif, the researchers who found it, turned that into heap disclosure and remote code execution.
They demonstrated code execution before authentication against default installations of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate, and after authentication against Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. They note there is no universal exploit: each application needs its own, and they have not published those. As of November 18 there are no public reports of exploitation in the wild.
Oracle rates the issue 8.1 (High) under CVSS 3.1. The researchers rate it 9.2 (Critical) under CVSS 4.0. CISA has issued an alert urging immediate patching.
How to find out if you’re exposed
Java version. The JVM is 17.0.6 or later and does not yet include the fix. The fixed OpenJDK versions are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Vendors add their own suffixes, but in the builds we checked, the build string printed by java -version contains one of those four numbers when the runtime is fixed.
CPU. The host is x86-64 and supports AVX-512 VBMI: Intel Xeon from Ice Lake onward, AMD EPYC and Ryzen from Zen 4 onward. ARM64 hosts are not affected.
Reachability. Data an attacker controls reaches Java’s Base64 decoder. That includes Authorization headers, tokens, SAML messages and file uploads. A Java client that opens a TLS connection to a malicious server is also in scope. For anything that accepts network input, assume this is true.
All three of these must be true
To check a host’s CPU, run this on the host or Kubernetes node. Hardened runtime images have no shell, so it will not run inside the container.
UseAVX = 3 means the JVM is using AVX-512 on that host. Treat the host as affected until the full check says otherwise. A value of 0 to 2 means AVX-512 is not in use. On ARM64 nothing is printed. The answer applies only to the host the command ran on.
Ask Kubernetes. kubectl get nodes -L kubernetes.io/arch,node.kubernetes.io/instance-type shows the architecture and instance type of every node. If you run Node Feature Discovery, nodes with the instruction set carry the label feature.node.kubernetes.io/cpu-cpuid.AVX512VBMI=true.
Check build runners and CI workers as well. They run Java, and they talk to the network.
UseAVX = 3 means the JVM is using AVX-512 on that host. Treat the host as affected until the full check says otherwise. A value of 0 to 2 means AVX-512 is not in use. On ARM64 nothing is printed. The answer applies only to the host the command ran on.
Ask Kubernetes. kubectl get nodes -L kubernetes.io/arch,node.kubernetes.io/instance-type shows the architecture and instance type of every node. If you run Node Feature Discovery, nodes with the instruction set carry the label feature.node.kubernetes.io/cpu-cpuid.AVX512VBMI=true.
Check build runners and CI workers as well. They run Java, and they talk to the network.
Where Docker Hardened Images stand
Java runtime in DHI
DHI status
Amazon Corretto 17, 21, 25, 27
Fixed. The published images report 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 and 27.0.1.1.4.
SapMachine 21, 25, 27
Fixed. The published images report 21.0.13.1+2, 25.0.5.1+2 and 27.0.1.1+4.
Azul Zulu 17, 21, 25, 27
Fixed. The published Zulu images we checked report 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2 and 27.0.1.1+4.
Eclipse Temurin 17, 21, 25, 27
Waiting for Adoptium to complete its release. On November 18 Adoptium had published 27.0.1.1+4 for x86-64 Linux only. 17.0.21.1, 21.0.13.1 and 25.0.5.1 were still in testing. Adoptium tracks progress in adoptium/temurin#326. Our published images still report 17.0.21+9, 21.0.13+9, 25.0.5+8 and 27.0.1.0.2+1, which are vulnerable.
Java 26 (any vendor)
Java 26 reached end of support in September 2026, so no fix is expected from any vendor, and it is not among the fixed lines in the OpenJDK advisory. If you run it, treat it as affected and keep the flag set. We recommend moving to Java 25 or updating to Java 27. If you cannot migrate yet, ask us whether Extended Lifecycle Support can cover your version. It is the Docker Hardened Images Enterprise add-on for software past its upstream end of life.
Java 8 and 11
Not affected by this CVE and no action is needed for it. The same November update fixes other issues in these lines, so update when new images arrive.
Application images that bundle Java, such as Keycloak, Jenkins, Kafka, Elasticsearch and Solr
They follow the bundled runtime, which for many of them is Temurin, and they are rebuilt once the runtime they use is fixed. Until then, set the flag yourself.
Set the mitigation flag yourself on every JVM that is still waiting for a fixed runtime, and check what each image already sets before you do. Treat the flag as a stopgap, because a JVM is protected only if the flag reaches it when it starts, and a deployment setting or a start script can override it or drop it. A fixed runtime is the only thing that closes the issue, so move to the fixed image as soon as it is published.
Next Steps:
If you are not running Docker Hardened Images yet
The CPU check and the mitigation flag in the steps below apply to any image that runs a HotSpot-based OpenJDK build. The version strings in this post come from Docker Hardened Images, so for an image from another source, confirm the fixed build in that source’s advisory.
The fixed build can only come from whoever builds your image, because the Java runtime and the system packages your application runs on come from the image underneath it. That dependency is why a hardened image is a necessary step toward a trusted software supply chain. With Docker Hardened Images, tracking each vendor’s fix and rebuilding on it is work Docker does for you. The images are minimal and secure by default, and they are built to serve as a trusted and verifiable upstream for your builds. You can move a service onto one by following the migration guide.
If you have Docker Hardened Images deployed
1. Find the Java in your deployments, by version. Look for DHI Java runtime images, DHI application images that bundle Java, and your own images built on either. Include JVMs you add in your own layers. Ask each runtime for its version. This works on hardened images, which have no shell:
docker run –rm –entrypoint java <image> -version
Compare the result with the fixed versions above. Temurin-21.0.13+9 is vulnerable. Corretto-21.0.13.1.2 is fixed.
Do not rely on a vulnerability scan alone for this. The public vulnerability databases were still incomplete for this CVE on November 18.
Set the flag. For most deployments, set JAVA_TOOL_OPTIONS on the container:
docker run -e JAVA_TOOL_OPTIONS=”-XX:-UseBASE64Intrinsics” <your-image>
Three cases need more care, and the next section covers them: images that already set Java option variables (our FIPS images do), environments that also run Java 8, and anything that starts more than one JVM.
Prefer this flag to -XX:UseAVX=2, the other published mitigation. UseAVX does not exist on ARM64, and a JVM given it there will not start. Applications that decode very large volumes of Base64 may run slower with the flag. Test before a wide rollout.
The flag addresses this CVE only. The same OpenJDK release fixes nine other CVEs, including two rated 7.4 that affect every Java line from 8 to 27. Only the fixed image addresses those.
Restart, then verify. The flag is read only at JVM startup. It cannot be changed in a running JVM, so every JVM has to be restarted. Then look for this line in the container log:
Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics
Check your CPUs, and keep checking. Run the CPU command on every node pool. A cluster with mixed instance types can schedule the same pod onto an affected node tomorrow. If any node in a pool is affected, treat the workload as affected.
Reduce exposure. Restrict network access to Java services that do not need to be public, starting with identity, CI/CD and collaboration systems. The researchers note that a proxy which buffers whole request bodies gets in the way of some of their exploits but not all of them, so do not count on it.
Watch for crashes, and think about secrets. A failed attempt can crash the JVM. In the container log a crash starts like this:
# A fatal error has been detected by the Java Runtime Environment: # # SIGSEGV (0xb) at pc=0x…, pid=1, tid=…
The JVM also writes a report named hs_err_pid<pid>.log inside the container. That file is gone when the container is replaced, which in Kubernetes happens straight away. To keep it, point -XX:ErrorFile at a mounted volume. The malformed input is also rejected with an IllegalArgumentException, so a burst of Base64 decoding errors in an application’s log is worth a look. Neither signal is reliable, and a service that stays up is not proof that nothing happened.
The researchers could read the Java heap before they could run code. If you have reason to believe an exposed JVM on affected hardware was attacked, treat the keys, tokens and passwords it held as disclosed, and rotate them.
Making the flag reach every JVM
A container often runs more than one JVM, for example when a build tool forks a JVM for tests, an application server starts helper processes or a CI agent starts a JVM for every build step. The flag protects only the JVMs that receive it, and the variable most people reach for first is JAVA_OPTS, which Java does not read at all.
Where you put the flag
What reads it
Child JVMs get it?
Watch out for
JAVA_TOOL_OPTIONS
The JVM itself, however it is started. Includes javac, keytool and other JDK tools.
Yes, through the inherited environment
A Java 8 JVM that sees it refuses to start. Some DHI FIPS images already set this variable.
JDK_JAVA_OPTIONS
Only the java launcher, Java 9 and later
Yes, when the child is started with java
Not read by javac, keytool or other JDK tools. DHI FIPS images set it. Java 8 ignores it.
The java command line
That one JVM
No
Nothing downstream inherits it.
JAVA_OPTS, JENKINS_JAVA_OPTS, MAVEN_OPTS, ES_JAVA_OPTS and similar
A start script, which copies the value onto one java command line
No
Each script has its own rules. If nothing in the image reads the variable, it does nothing.
Five rules follow from that table. We tested each on DHI images.
JAVA_OPTSonly works where a script reads it. With JAVA_OPTS=”-XX:-UseBASE64Intrinsics” set and a plain java command, the intrinsic stays on. No warning is printed.
A flag on the command line stops at that process. We started a JVM with the flag on its command line and had it start a second JVM. The child ran with the intrinsic on. With JAVA_TOOL_OPTIONS or JDK_JAVA_OPTIONS in the environment, the child ran with it off. A child started with a cleared environment gets nothing, whichever variable you use.
Check what the image already sets before you set anything. In Docker and Kubernetes, your value replaces the image’s value. It is not appended.
Our FIPS images use these variables to configure the FIPS provider. dhi.io/eclipse-temurin:21-fips sets both. When we replaced its JDK_JAVA_OPTIONS with only the flag, the JVM started normally, but the org.bouncycastle.fips.approved_only property was gone. Nothing warned us. If the command prints a value, copy it and add the flag at the end:
env: – name: JDK_JAVA_OPTIONS value: “<the existing value from the image> -XX:-UseBASE64Intrinsics”
Not every FIPS image uses the same variables, so run the check for each image.
KeepJAVA_TOOL_OPTIONSaway from Java 8. Java 8 is not affected and does not know the flag:
Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics Unrecognized VM option ‘UseBASE64Intrinsics’ Error: Could not create the Java Virtual Machine.
Adding -XX:+IgnoreUnrecognizedVMOptions to the variable does not help on Java 8. Where Java 8 shares an environment with a newer Java, either scope the variable to the containers that need it or use JDK_JAVA_OPTIONS, which Java 8 ignores. Java 11 accepts the flag, so it is harmless there.
Verify the process, not the environment. Running java -XX:+PrintFlagsFinal -version inside a container starts a new JVM. It tells you what the environment gives a new JVM, not what the JVM already serving traffic was started with. For the running process, use the startup log line. JDK_JAVA_OPTIONS prints one too, starting with NOTE: Picked up. In an image that includes the JDK you can also ask the process directly:
The answer must be -XX:-UseBASE64Intrinsics. If the flag reached the JVM through an environment variable, it will not show in the process’s command line, so ps is not a reliable check.
Some applications discard these variables on purpose. Elasticsearch’s start script, for example, ignores JAVA_TOOL_OPTIONS and expects ES_JAVA_OPTS. Check your application’s documentation.
When the fixed images arrive
Pull the new image and redeploy. Four things catch people out:
The tag may not change. dhi.io/amazoncorretto:21.0.13 now reports the fixed Corretto-21.0.13.1.2, a newer build than the tag name suggests. A tag cannot tell you which build you are running. java -version can.
Kubernetes may not pull. With imagePullPolicy: IfNotPresent, the default for every tag except latest, a node that already holds the old image under that tag keeps using it, even after a restart. Deploy by digest, or set the policy to Always for this rollout.
Mirrors lag. If you copy DHI into your own registry, the fix arrives when your mirror next syncs.
Your own images need a rebuild. An image built FROM a DHI Java image keeps the old runtime until you rebuild and redeploy it.
Then confirm with java -version that what is running reports a fixed build. After that, remove the flag from every place you set it.
The NGINX HTTP/2 flaws are fixed in the same catalog
The day after Java4Shell, NGINX released fixes for two memory errors in the way it handles HTTP/2 connections, tracked as CVE-2026-123007 and CVE-2026-123633. A crafted request can crash a worker process, and where an attacker gets past the operating system’s memory protections it can run code inside that worker. Both flaws need HTTP/2 to be enabled on the server, and the same releases fix other NGINX issues that do not depend on HTTP/2, so update either way.
The Docker Hardened Images for NGINX were rebuilt on NGINX 1.30.7 and 1.31.9 and published on November 18, the same day as the upstream release. To patch, pull the image again and redeploy, and move any tag pinned to an older exact version to a fixed one. nginx -v prints the version, and the fixed ones are 1.30.7 and 1.31.9. The notes on pull policy, mirrors and your own images in the section above apply to NGINX images in the same way.
Who does what
The vulnerable code is in the Java runtime inside the image, and if you are using DHI, shipping the fix becomes our job. Whether that code can be reached in your deployment depends on things an image cannot see: the CPU it is scheduled onto, the options you start it with, the processes it starts, and the traffic you send it.
With Docker Hardened Images, Docker will
Without Docker Hardened Images
Track every Java vendor and ship fixed runtimes in DHI as soon as they are released
Track every Java vendor yourself and rebuild your base images on each fixed runtime
Tell you which images are fixed and which are still waiting
Find out from each vendor which of its builds are fixed
Tell you what we know, and update this post
Follow the OpenJDK, Oracle and vendor advisories as they change
Three jobs stay with you whichever image you run.
Pull the fixed images, redeploy, and confirm the Java version that is actually running.
Make sure the flag is set on every JVM that is still waiting for a fixed runtime.
Know which CPUs your workloads run on, control what can reach your Java services, and patch the JVMs you add yourself.
So how many more bullets are you willing to dodge?
It was only four weeks ago that the news was PHP2Shell and the eMudhra certificate compromise. Calif, the security research team that found Java4Shell and helped find PHP2Shell, says it used AI to find this flaw in about an hour and that the whole effort cost less than $200 in tokens. When a flaw like this can be found and weaponized at that price, it is reasonable to expect more of them.
If you lead a team or answer for how your organization builds and ships software, the questions after a week like this one are whether you were exposed and how quickly you can prove you were not. It is imperative to have a trusted foundation in place before the next flaw appears, and Docker Hardened Images is that foundation to adopt. This week Docker began publishing fixed Java and NGINX images to the catalog within a day of each disclosure, with the images still waiting listed in the status table above. Each image ships with a signed SBOM and SLSA Build Level 3 provenance, so you have a record of what it contains and how it was built.
The Docker Hardened Images catalog is free and open source under Apache 2.0, and moving one of your services onto a hardened image typically means changing one line in its Dockerfile. If you are not building on Docker Hardened Images yet, start today.
Today, Docker is officially launching its new brand, and I’m excited to tell you what it’s all about and why we think now is the time for change.
Let’s start with the big picture. We’re living through a transformative moment: for Docker, for developers, for the industry, and quite possibly, for humanity itself. AI is creating possibilities that would have sounded like science fiction not long ago.
But it’s also forcing the industry to confront an almost existential question: how do we harness all that power and intelligence without compromising security, governance, or control? Or, put more simply: how do we get to a point where we can actually trust agents?
That one seemingly simple yet infinitely complex question is why we’re here today, introducing you to a new Docker.
A new Docker, but a familiar story.
We’ve been here before
Ok, not exactly here, but once upon a time, a decade or so ago, the tech industry was at a similar inflection point. Digital transformation was the term du jour, promising a new way of engaging customers and powering the global economy. There was one big constraint, though: teams needed a better way to build, ship, and run software consistently across any environment.
Enter a company you might have heard of: Docker.
Together with all of you, Docker built the standard trusted by millions of developers. For over a decade, developers have relied on us to make software portable, open, reproducible, and secure. Docker turned the frustration of “Well, it works on my machine!” into the assurance that “Yes, it works everywhere.”
Today, of course, the challenge confronting us is new and evolving, and we all need to evolve with it. We cannot simply continue to do what we’ve always done and expect to succeed in this new era. That applies to business leaders, developers, tech companies, everyone. It certainly applies to Docker. That’s what this rebrand is about: evolving to meet the moment for our customers.
What isn’t changing
Let me be unequivocal: this is not about leaving Docker’s legacy or heritage behind. We’ve spent more than a decade earning your trust. This is about building on that foundation, not replacing it.
The qualities you value us for aren’t changing. We’re still committed to openness and industry collaboration. We’re still, and always will be, developer-first. We’re still fanatical about simplicity, and about showing up everywhere you need us.
On the product front, the containers you know and love aren’t going anywhere. Containers still play a huge role in the software development lifecycle. As long as that’s the case, Docker will continue leading the way.
Containers weren’t designed for agents
Agents have introduced a new problem. Containers isolate workloads. But agents aren’t workloads. Agents are actors.
Agents make their own decisions about what to run, what to access, and what to change. Developers and enterprises need solutions built specifically to isolate and govern them, so they can give those agents real autonomy without giving up control.
Docker’s next chapter is about delivering exactly that: security, isolation, and governance, so we can all trust agents to do meaningful work without feeling like we’re always one step from catastrophe.
Run on trust
In case I haven’t made it blindingly obvious yet, the new Docker is all about trust.
Trust Docker because our track record speaks for itself. Trust Docker because we’re proven, neutral, and secure. Trust Docker because it’s pretty darn clear you can’t trust the agents to manage themselves.
Trust us because we have a software supply chain that is already the standard for building securely. Trust us because nobody isolates agents where they run better than we do. Trust us because we’re taking a comprehensive approach to improving governance and minimizing risk across the entire enterprise.
Trust Docker because we’re not egotistical enough to think we can solve a challenge this big alone. Trust us because everything about our history, our heritage, and our actions over the past year tells you we’ll partner with the smartest and build alongside the best, and not create vendor lock-in.
Most of all, trust Docker because we’re not just talking the talk. We’ve got the goods to back it up: trusted supply chain for your agents to build from, trusted runtime to isolate your agents, and a trusted ecosystem to ensure all the layers of trust are covered, whether made by Docker or not.
A whale of an evolution
As our product team innovated to meet the moment and our messaging in the market began to shift, one thing became clear: the speed and scale of evolution happening inside Docker called for an equally momentous evolution on the outside. Something that makes it unmistakably clear that it’s a new day for Docker. Something that says and shows, loud and clear, for all the world to see, that Docker is not just about containers anymore.
Something big.
Something, dare I say, whale sized.
I’m talking, of course, about our beloved Moby.
If you know Docker, then you know Moby, and if Docker is evolving, Moby should too. The only question was to how and to what extent? We looked at a lot of whales, folks. (I may or may not have been seeing whales in my sleep.) Ultimately, with the help of our friends at the strategic brand transformation company, Motto, we landed on a new Moby for the new Docker.
Watch Moby’s transformation here:
In many ways, Moby is a microcosm for Docker and the changes we’re making: the Moby you love and trust, evolved for a new era. Just as the new Docker is no longer singularly defined by containers, neither is the new Moby.
Come take a look around
We’ve got lots to show you. Poke around our new website. Find and engage with the new Docker brand on social media. And if you want to see what trust in the agentic era looks like in practice, try Docker Sandboxes and Docker AI Governance. We’d love to hear what you think.
Wherever this new era takes us, Docker will always honor and cherish the trust you continue to place in us. Now, let’s go build what’s next.
Every Flutter app has the same chore hiding in it: the network layer. A Dio instance, a base URL, an error model, a model class per endpoint with fromJson and toJson, a service that wraps the calls, and — if you are disciplined — tests with fixtures and mocks.
None of it is hard. All of it is repetitive. And in 2026 it is exactly the kind of work you should not be typing by hand.
This post covers four things:
Why vexana: what it handles for you that plain dio doesn’t.
Building a user list, step by step, from model to screen.
The live playground, so you can try it without installing anything.
The new vexana AI skills: four skills your AI assistant can follow to set up the layer, turn JSON into models, services, fakes and tests, and migrate old projects.
1. Why vexana?
vexana is a networking layer for Flutter built on dio. You keep everything dio gives you (interceptors, adapters, CancelToken, FormData) and stop rewriting the parts every app ends up needing.
Where does the name come from? Vexana is a hero in Mobile Legends, and the one I loved playing the most. When I was writing a library whose whole job is to pull data in from the network, her name was the first thing that came to mind, and it stuck.
Typed models and a sealed result
You parse into your own classes, not Map<String, dynamic>, and every request returns a NetworkResult: either NetworkSuccessResult with your data or NetworkErrorResult with the error. It's a sealed class, so a switch that forgets the error case doesn't compile.
final result = await manager.sendRequest<User, List<User>>( '/users', parseModel: const User(), method: RequestType.GET, );
Prefer callbacks? result.fold(onSuccess: ..., onError: ...) does the same.
Refresh tokens without the race conditions
When a request comes back 401, vexana calls your onRefreshToken callback and retries the original request with the new token. 401s are handled one at a time in a queue, so parallel requests don't race each other with half-refreshed tokens; once the token is refreshed, they all go through. If the retried request still fails after maxRetryCount attempts, onRefreshFail runs, which is where you send the user back to login.
newService is a separate manager without the refresh interceptor, so your refresh call can't end up refreshing itself.
Your API’s error body, parsed
Give the manager your error model and error responses are parsed into it, so the UI reads error.model?.message instead of digging through a raw response.
Pass a fileManager (LocalFile or LocalPreferences) to the manager, then add expiration to any request. Until it expires, the same request is answered from the cache: no network call, typically in about a millisecond. cache.removeAll() clears it, for example on logout.
final manager = NetworkManager<EmptyModel>( options: BaseOptions(baseUrl: 'https://api.example.com'), fileManager: LocalFile(), // or LocalPreferences() );
await manager.sendRequest<User, List<User>>( '/users', parseModel: const User(), method: RequestType.GET, expiration: const Duration(minutes: 10), ); await manager.cache.removeAll(); // e.g. on logout
No-network retry, built in
Pass noNetwork: NoNetwork(context) and a request that fails for lack of a connection shows a bottom sheet with a retry button. You can supply your own widget with customNoNetwork.
A request logger (isEnableLogger), file upload with FormData, downloads with progress, CancelToken support, and it runs on mobile and on the web, including WebAssembly.
final manager = NetworkManager<EmptyModel>( options: BaseOptions(baseUrl: 'https://api.example.com'), isEnableLogger: true, );
The first type argument is the model to parse, and the second is what you get back: List<User> because /users returns a JSON array. With expiration, calls in the next five minutes come from the cache.
The switch covers loading (null), success and error, and the compiler checks that none is missing.
The result
the user list running in the browser
Notice what is not there: no jsonDecode, no try/catch around the request, no Map<String, dynamic> in the UI. The package's example has the same pattern as a complete page, with pull-to-refresh.
3. Try it in your browser: the playground
Reading about a networking library only gets you so far. The vexana playground is a Flutter Web app (compiled to WebAssembly) that runs the real package:
Turn on Cache, set the expiration, and send the same request again. The first call goes to the network (around 400 ms); the second comes back from the cache in about 1 ms and is marked cache hit.
Turn on the Logger to see what vexana does under the hood.
The Session metrics table shows count, p50, p95, max, errors and cache hits for each endpoint, with network and parse time listed separately.
It’s the quickest way to see how the options behave before you add the package to your app.
4. Let your AI assistant write the boilerplate: vexana AI skills
This is the part I’m most excited about.
You could ask an AI assistant to “write a vexana model for this JSON” and hope for the best. Sometimes you’d get the old API, sometimes a model that doesn’t compile, and almost never tests.
So vexana now ships AI skills: a set of playbooks written by the package maintainers. Each skill contains the exact vexana 6 API, templates that have been compiled and tested, and a procedure that ends by running dart analyze and flutter test. The assistant doesn't improvise the layer; it follows a playbook.
The skills are plain Markdown files (SKILL.md), so they aren't tied to one tool.
Other AI assistants (Cursor, GitHub Copilot, Codex, Gemini CLI, …): copy the plugins/vexana/skills folder into your project and ask the assistant to follow a skill, for example "follow skills/add/SKILL.md for this JSON".
There are four skills. The examples below use Claude Code’s command syntax; with another assistant, describe the same request in plain words.
/vexana:init: set up the layer
/vexana:init base URL https://api.example.com, cache LocalFile
It reads your project first and puts files where your structure expects them. If you already have lib/product/… or lib/core/…, it uses that instead of inventing a new layout. Then it:
adds vexana and mocktail (dev),
creates a single AppNetworkManager whose base URL can be overridden with --dart-define=BASE_URL=...,
generates an error model if you paste an error response,
adds a small fixture helper for tests.
Run it twice and nothing changes. It never overwrites your files.
/vexana:add: JSON in, typed code out
/vexana:add GET /posts and GET /posts/{id}, feature post, JSON in api/posts.json
From one JSON sample you get:
a Post model (nested objects become their own classes),
a PostService behind an IPostService interface, using sendRequest,
the sample saved as a test fixture,
a round-trip test: fixture → fromJson → toJson → same JSON.
Keys like class, default, 2fa or user-name become valid Dart fields (class_, default_, n2fa, userName), while the original JSON keys are kept for parsing.
1 in one element and 1.5 in another means double.
An empty array or a field that is always null is typed as Object?, and the report lists it so you can decide the real type instead of the tool guessing.
/vexana:multiple-add: a whole API at once
Point it at a folder of JSON responses:
/vexana:multiple-add api_samples/ — GET /posts, GET /users, GET /comments, GET /companies
It first shows a plan (model, feature, endpoint) and waits for your OK. Then, for each feature, it writes:
the model(s), with shared types deduplicated: if users.json has a nested company and companies.json has the same shape, you get one Company class;
the service and its interface;
a Fake service with a few embedded sample items, so you can build UI before the backend is ready;
mocktail service tests (success and error for every method) and model tests.
In my test run, four JSON files became 20 files and 16 passing tests, with dart analyze reporting no issues.
/vexana:refactor: bring old projects to vexana 6
/vexana:refactor
For projects on vexana 4.x or 5.x, it:
runs your tests first to record a baseline,
shows the planned changes and asks before touching anything,
bumps the dependency and fixes imports that no longer exist,
flags the calls whose behaviour changed, with an explanation. For example, removeAll() now clears only that manager's cache, and sendPrimitive now runs through your interceptors.
At the end it compares your tests against the baseline, so a regression isn’t mistaken for a failure that was already there.
Why skills and not just a prompt?
Because the skills already contain the parts you would otherwise have to check yourself:
The right API. The skills carry a reference of the vexana 6 surface, so there are no hallucinated methods.
Tested templates. Every template was compiled and tested in a real Flutter project before it went into the plugin.
Verification. Every command ends with dart analyze and flutter test, and reports failures as they are instead of claiming success.
Safe defaults. It asks before overwriting, asks on name collisions, and waits for confirmation on bulk changes.
If the skills save you an afternoon of boilerplate, a star on GitHub helps other Flutter developers find it. And if a skill generates something you’d write differently, open an issue: the templates are plain Markdown and easy to improve.