The community around Kubernetes includes a number of Special Interest Groups (SIGs) and Working Groups (WGs) facilitating discussions on important topics between interested contributors. Today, we're excited to announce the formation of the AI Gateway Working Group, a new initiative focused on developing standards and best practices for networking infrastructure that supports AI workloads in Kubernetes environments.

What is an AI Gateway?

In a Kubernetes context, an AI Gateway refers to network gateway infrastructure (including proxy servers, load-balancers, etc.) that generally implements the Gateway API specification with enhanced capabilities for AI workloads. Rather than defining a distinct product category, AI Gateways describe infrastructure designed to enforce policy on AI traffic, including:

• Token-based rate limiting for AI APIs.
• Fine-grained access controls for inference APIs.
• Payload inspection enabling intelligent routing, caching, and guardrails.
• Support for AI-specific protocols and routing patterns.

Working group charter and mission

The AI Gateway Working Group operates under a clear charter with the mission to develop proposals for Kubernetes Special Interest Groups (SIGs) and their sub-projects. Its primary goals include:

• Standards Development: Create declarative APIs, standards, and guidance for AI workload networking in Kubernetes.
• Community Collaboration: Foster discussions and build consensus around best practices for AI infrastructure.
• Extensible Architecture: Ensure composability, pluggability, and ordered processing for AI-specific gateway extensions.
• Standards-Based Approach: Build on established networking foundations, layering AI-specific capabilities on top of proven standards.

Active proposals

WG AI Gateway currently has several active proposals that address key challenges in AI workload networking:

Payload Processing

The payload processing proposal addresses the critical need for AI workloads to inspect and transform full HTTP request and response payloads. This enables:

AI Inference Security

• Guard against malicious prompts and prompt injection attacks.
• Content filtering for AI responses.
• Signature-based detection and anomaly detection for AI traffic.

AI Inference Optimization

• Semantic routing based on request content.
• Intelligent caching to reduce inference costs and improve response times.
• RAG (Retrieval-Augmented Generation) system integration for context enhancement.

The proposal defines standards for declarative payload processor configuration, ordered processing pipelines, and configurable failure modes - all essential for production AI workload deployments.

Egress gateways

Modern AI applications increasingly depend on external inference services, whether for specialized models, failover scenarios, or cost optimization. The egress gateways proposal aims to define standards for securely routing traffic outside the cluster. Key features include:

External AI Service Integration

• Secure access to cloud-based AI services (OpenAI, Vertex AI, Bedrock, etc.).
• Managed authentication and token injection for third-party AI APIs.
• Regional compliance and failover capabilities.

Advanced Traffic Management

• Backend resource definitions for external FQDNs and services.
• TLS policy management and certificate authority control.
• Cross-cluster routing for centralized AI infrastructure.

User Stories We're Addressing

• Platform operators providing managed access to external AI services.
• Developers requiring inference failover across multiple cloud providers.
• Compliance engineers enforcing regional restrictions on AI traffic.
• Organizations centralizing AI workloads on dedicated clusters.

Upcoming events

KubeCon + CloudNativeCon Europe 2026, Amsterdam

AI Gateway working group members will be presenting at KubeCon + CloudNativeCon Europe in Amsterdam, discussing the problems at the intersection of AI and networking, including the working group's active proposals, as well as the intersection of AI gateways with Model Context Protocol (MCP) and agent networking patterns.
This session will showcase how AI Gateway working group proposals enable the infrastructure needed for next-generation AI deployments and communication patterns.
The session will also include the initial designs, early prototypes, and emerging directions shaping the WG’s roadmap.
For more details see our session here:

• AI'm at the Gate! Introducing the AI Gateway Working Group in Kubernetes

Get involved

The AI Gateway Working Group represents the Kubernetes community's commitment to standardizing AI workload networking. As AI becomes increasingly integral to modern applications, we need robust, standardized infrastructure that can support the unique requirements of inference workloads while maintaining the security, observability, and reliability standards that Kubernetes users expect.
Our proposals are currently in active development, with implementations beginning across various gateway projects. We're working closely with SIG Network on Gateway API enhancements and collaborating with the broader cloud-native community to ensure our standards meet real-world production needs.

Whether you're a gateway implementer, platform operator, AI application developer, or simply interested in the intersection of Kubernetes and AI, we'd love your input. The working group follows an open contribution model - you can review our proposals, join our weekly meetings, or start discussions on our GitHub repository. To learn more:

• Visit the working group's umbrella GitHub repository.
• Read the working group's charter.
• Join the weekly meeting on Thursdays at 2PM EST.
• Connect with the working group on Slack (#wg-ai-gateway) (visit https://slack.k8s.io/ for an invitation).
• Join the AI Gateway mailing list.

The future of AI infrastructure in Kubernetes is being built today, join up and learn how you can contribute and help shape the future of AI-aware gateway capabilities in Kubernetes.

Recently, I was searching for a way to style an element depending on whether it was ever focused.

I wanted to do this without JavaScript, just with CSS, because I was going to use it in a demo about the new focusgroup web platform feature. Focusgroup handles a lot of keyboard navigation logic for you, for free, with only an HTML attribute. So adding a bunch of JavaScript code to track past focus states to that demo felt like a step back.

I kept thinking about this problem, but couldn't find a solution. See, storing a click state is easy. You can use a checkbox element and then apply styles based on whether its :checked pseudo-class matches. You can also hide the checkbox itself and only show its corresponding <label> element if you prefer. Heck, you can even put your checkbox anywhere you want and then use the :has() pseudo-class to style other elements based on that checkbox's state.

But, I couldn't find anything similar for tracking if an element had been focused. And then, it hit me: what if I used a CSS animation for this?

Using CSS animations as state machines

CSS animations are basically state machines. They can change the value of any property over time. The trick is advancing the time to the right point, in order to reach the state you want to remember, and then keep it there.

Fortunately, CSS animations come with two very useful properties:

• animation-play-state, which we can use to pause the animation in its initial state.
• animation-fill-mode: forwards, which we can use to keep the animation in its end state after it finishes.

Let's use these properties to set up our animation:

.remember-focus {
  animation-name: remember-focus;
  animation-duration: 0.000001s;
  animation-timing-function: linear;
  animation-fill-mode: forwards;
  animation-play-state: paused;
}

Or, using the shorthand syntax:

.remember-focus {
  animation: remember-focus 0.000001s linear forwards paused;
}

The .remember-focus class sets an animation on the element, keeping it paused for now, but filling forwards so it retains the end state once it runs.

Notice the weirdly short animation duration of 0.000001s. That's because we want the animation to reach its end state immediately after starting. The duration needs to be short enough to be effectively instant to the user.

Whenever we're ready to change the state, all we have to do is play the animation. Let's say we want to do this when the element receives the user focus:

.remember-focus:focus {
  animation-play-state: running;
}

Now all we need to do is define the animation itself, via the @keyframes rule. Let's use background colors for now, to make things simple:

@keyframes remember-focus {
  from {
    background: red;
  }
  to {
    background: blue;
  }
}

And there we have it. By default, the element on which the .remember-focus class is applied will have a red background. And then, when it receives focus, the animation will run and immediately change the background color to blue. Because of animation-fill-mode: forwards, the element will stay blue even after it loses focus.

The cool thing is that that state of the animation is associated to its element, so even if multiple elements have the .remember-focus class, each one will remember its own focus state independently.

Demos

Here's a live demo of the code we've just seen. Click or tab to focus the box: the color changes. The color stays even if click somewhere else or tab to another element:

This technique works with the :hover pseudo-class as well. Just change the selector to .remember-focus:hover and the animation will run on hover instead of focus.

Here's a demo that uses hover instead of focus, and has multiple elements with the same class. Try hovering over the boxes below to see them change color:

Animating other properties

Of course changing colors is just a simple thing you can do with this. But, CS animations are capable of changing any property, including custom properties, and even properties that can't be animated.

For example, you could use this technique to add a checkmark icon next to an element that was focused by animating the content property of a pseudo-element, even if content is not animatable.

Try it yourself: click the first box below, and then use tab to navigate to the next boxes. You'll see a checkmark appear next to the boxes you've already focused:

Using style container queries as an if statement

Let's conclude by refactoring the code a little bit so it's easier to reuse in multiple places.

First, let's use the technique to swap the value of a custom property called --was-focused:

.track-focus {
  --was-focused: false;
  animation: track-focus 0.000001s linear forwards paused;
}
.track-focus:focus-within {
  animation-play-state: running;
}
@keyframes track-focus {
  to { --was-focused: true; }
}

Now, we can use this by applying the .track-focus class to any element we want to track the focus state of. For example, a couple of form labels with inputs in them:

<form class="my-form">
  <label class="track-focus" for="name">
    Your name
    <input type="text" id="name">
  </label>
  <label class="track-focus" for="email">
    Your email
    <input type="text" id="email">
  </label>
</form>

Then, to actually use the --was-focused property, we can use a container style query. This way, we can conditionally apply styles to the element itself or to any of its descendants, depending on whether it was ever focused:

@container style(--was-focused: true) {
  input {
    background: lightgreen;
  }
}

And here is the result:

That's it. Let me know if you find a cool use case for this technique, or if you have other ideas to improve it.

• Setting up a Python monorepo with uv workspaces
• cattrs: Flexible Object Serialization and Validation
• Learning to program in the AI age
• VS Code extension for FastAPI and friends
• Extras
• Joke

About the show

Sponsored by us! Support our work through:

• Our courses at Talk Python Training
• The Complete pytest Course
• Patreon Supporters Connect with the hosts
• Michael: @mkennedy@fosstodon.org / @mkennedy.codes (bsky)
• Brian: @brianokken@fosstodon.org / @brianokken.bsky.social
• Show: @pythonbytes@fosstodon.org / @pythonbytes.fm (bsky) Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Monday at 11am PT. Older video versions available there too. Finally, if you want an artisanal, hand-crafted digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it.

Brian #1: Setting up a Python monorepo with uv workspaces

• Dennis Traub
• The 3 things
  • Give the Root a Distinct Name
  • Use workspace = true for Inter-Package Deps
  • Use importlib Mode for pytest

Michael #2: cattrs: Flexible Object Serialization and Validation

• cattrs is a Swiss Army knife for (un)structuring and validating data in Python.
• A natural alternative/follow on from DataClass Wizard
• Converts to ←→ from dictionaries
• cattrs also focuses on functional composition and not coupling your data model to its serialization and validation rules.
• When you’re handed unstructured data (by your network, file system, database, …), cattrs helps to convert this data into trustworthy structured data.
• Batteries Included: cattrs comes with pre-configured converters for a number of serialization libraries, including JSON (standard library, orjson, UltraJSON), msgpack, cbor2, bson, PyYAML, tomlkit and msgspec (supports only JSON at this time).

Brian #3: Learning to program in the AI age

• Jose Blanca
• “I teach a couple of introductory Python courses and I've been thinking about which advice to give to my students, that are studying how to program for the first time. I have collected my ideas in these blog posts”
  • Why learning to program is as useful as ever, even with powerful AI tools available.
  • How to use AI as a tutor rather than a shortcut, and why practice remains the key to real understanding.
  • What the real learning objectives are: mental models, managing complexity, and thinking like a software developer.

Michael #4: VS Code extension for FastAPI and friends

• Enhances the FastAPI development experience in Visual Studio Code
• Path Operation Explorer: Provides a hierarchical tree view of all FastAPI routes in your application.
• Search for routes: Use the Command Palette and quickly search for routes by path, method, or name.
• CodeLens links appear above HTTP client calls like client.get('/items'), letting you jump directly to the matching route definition.
• Deploy your application directly to FastAPI Cloud from the status bar with zero config.
• View real-time logs from your FastAPI Cloud deployed applications directly within VS Code.
• Install from Marketplace.

Extras

Brian:

• Guido van Rossum interviews key Python developers from the first 25 years
  • Interview with Brett Cannon
  • Interview with Thomas Wouters Michael:
• IntelliJ IDEA: The Documentary | An origin story video
• Cursor Joined the ACP Registry and Is Now Live in Your JetBrains IDE
• What hyper-personal software looks like
• I’m doing in-person training again (limited scope):
  • On-site, hands-on AI engineering enablement for software teams with Michael

Joke: Saas is dead

Coding agents are becoming part of everyday development, but quality of responses and usefulness still depends on the best context as input. That context comes in different forms starting from your environment, the code in the workspace, the model training knowledge, previous memory, agent instructions, and of course your own starting prompt. On the .NET team we’ve really adopted coding agents as a part of our regular workflow and have, like you, learned the ways to improve our productivity by providing great context. Across our repos we’ve adopted our agent instructions and have also started to use agent skills to improve our workflows. We’re introducing dotnet/skills, a repository that hosts a set of agent skills for .NET developers from the team who is building the platform itself.

What is an agent skill?

If you’re new to the concept, an agent skill is a lightweight package with specialized knowledge an agent can discover and use while solving a task. A skill bundles intent, task-specific context, and supporting artifacts so the agent can choose better actions with less trial and error. This work follows the Agent Skills specification, which defines a common model for authoring and sharing these capabilities with coding agents. GitHub Copilot CLI, VS Code, Claude Code and other coding agents support this specification.

What we are doing with dotnet/skills

With dotnet/skills, we’re publishing skills from the team that ships the platform. These are the same workflows we’ve used ourselves, with first-party teams, and in engineering scenarios we’ve seen in working with developers like yourself.

So what does that look like in practice? You’re not starting from generic prompts. You’re starting from patterns we’ve already tested while shipping .NET.

Our goal is practical: ship skills that help agents complete common .NET tasks more reliably, with better context and fewer dead ends.

Does it help?

While we’ve learned that context is essential, we also have learned not to assume more is always better. The AI models are getting remarkably better each release and what was thought to be needed even 3 months ago, may no longer be required with newer models. In producing skills we want to measure the validity if an added skill actually improves the result. For each of our skills merged, we run a lightweight validator (also available in the repo) to score it. We’re also learning the best graders/evals for this type…and so is the ecosystem as well.

Think of this as a unit test for a skill, not an integration test for the whole system. We measure (using a specific model each run) against a baseline (no skill present) and try to score if the specific skill improved the intended behavior, and by how much. Some of this is taste as well so we’re careful not to draw too many hard lines on a specific number, but look at the result, adjust and re-score.

Each skill’s evaluation lives in the repository as well, so you can inspect and run them. This gives us a practical signal on usefulness without waiting for large end-to-end benchmark cycles. We will continue to learn in this space and adjust. We have a lot of partner teams trying different evaluation techniques as well at this level. The real test is you telling us if they have improved.

A developer posted this just recently on Discord sharing what we want to see:

The skill just worked with the log that I’ve with me, thankfully it was smartter[sic] than me and found the correct debug symbol. At the end it says the crash is caused by a heap corruption and the stack-trace points to GC code, by any chance does it ring a bell for you?

This is a great example of how a skill accelerated to the next step rapidly in this particular investigation for this developer. This is the true definition of success in unblocking and accelerating productivity.

Discovery, installation, and using skills

Popular agent tools have adopted the concept of plugin marketplaces which simply put are a registry of agent artifacts, like skills. The plugin definition serves as an organizational unit and defines what skills, agents, hooks, etc. exist for that plugin in a single installable package. The dotnet/skills repo is organized in the same manner, with the repo serving as the marketplace and we have organized a set of plugins by functional areas. We’ll continue to define more plugins as they get merged and based on your feedback.

While you can simply copy the SKILL.md files directly to your environment, the plugin concept in coding agents like GitHub Copilot aim to make that process simpler. As noted in the README, you can register the repo as a marketplace and browse/install the plugins.

/plugin marketplace add dotnet/skills

Once the marketplace is added, then you can browse any marketplace for a set of plugins to install and install the named plugin:

/plugin marketplace browse dotnet-agent-skills
/plugin install <plugin>@dotnet-agent-skills

They are now available in your environment automatically by your coding agent, or you can also invoke them explicitly.

/dotnet:analyzing-dotnet-performance

And in VS Code you can add the marketplace URL into the Copilot extension settings for Insiders, adding https://github.com/dotnet/skills as the location and then you can browse in the extensions explorer to install, and then directly execute in Copilot Chat using the slash command:

We acknowledge that discovery of even marketplaces can be a challenge and are working with our own Copilot partners and ecosystem to better understand ways to improve this discovery flow — it’s hard to use great skills if you don’t know where to look! We’ll be sure to post more on any changes and possible .NET specific tools to help identify skills that will make your project and developer productivity better.

Starting principles

Like evolving standards in the AI extensibility space, skills is fast moving. We are starting with the principle of simplicity first. We’ve seen in our own uses that a huge set of new tools may not be needed with well scoped skills themselves. Where we need more, we’ll leverage things like MCP or scripts, or SDK tools that already exist and rely on them to enhance the particular skill workflow. We want our skills to be proven, practical, and task-oriented.

We also know there are great community-provided agent skills that have evolved, like github/awesome-copilot which provide a lot of value for specific libraries and architectural patterns for .NET developers. We support all these efforts as well and don’t think there is a ‘one winner’ skills marketplace for .NET developers. We want our team to keep focused closest to the core runtime, concepts, tools, and frameworks we deliver as a team and support and learn from the community as the broader set of agentic skills help all .NET developers in many more ways. Our skills are meant to complement, not replace any other marketplace of skills.

What’s next

The AI ecosystem is moving fast, and this repository will too. We’ll iterate and learn in the open with the developer community.

Expect frequent updates, new skills, and continued collaboration as we improve how coding agents work across .NET development scenarios.

Explore dotnet/skills, try the skills in your own workflows, and share feedback on things that can improve or new ideas we should consider.

The post Extend your coding agent with .NET Skills appeared first on .NET Blog.

I'm excited to announce that we've released the NanaZip 6.5 Preview, now available for download.

Starting with NanaZip 6.0 Update 1 (6.0.1638.0) and 6.5 Preview (6.5.1638.0), we have fixed some security vulnerabilities reported by HO-9:

• CVE-2026-27709
• CVE-2026-27710
• CVE-2026-27711

Release Notes

This release includes all the improvements from NanaZip 6.0 Update 1 (6.0.1638.0).

Download

• MSIX Package: NanaZipPreview_6.5.1638.0.msixbundle

  • SHA-256: d7371d8632568125e8dc0c4cb5a6f2ee7b8bac16046cfb16f2c0f2f6507205eb

• License XML: NanaZipPreview_6.5.1638.0.xml

  • SHA-256: 2f6f59175dd05f9660c9b74e364a4fa5558d0948adfe3ba121e47f2ecf51e1ad

• Portable package: NanaZipPreview_6.5.1638.0_Binaries.zip

  • SHA-256: ea8092b0f7038b0666773654f705c80688206d28b4582613aac227bddcf567da

• Debug Symbols: NanaZipPreview_6.5.1638.0_DebugSymbols.zip

  • SHA-256: 6ff5a8f8daf37b09a319bb61c6d6f1a0608197b32b650a99f7a473b0749588ad

Kenji Mouri