Nvidia is rolling out a new GPU driver today (621.01) that enables Microsoft's new Advanced Shader Delivery technology to speed up game launches. The technology also removes mid-game "just-in-time" shader compilation, reducing stuttering and CPU spikes.

Microsoft's Advanced Shader Delivery works by offloading shader compilation for different hardware combinations to the cloud. "Using DirectX 12, Windows 11, and the Microsoft Agility SDK, developers capture shaders into a State Object Database (SODB), allowing Microsoft's cloud network to precompile shaders for hundreds of thousands of hardware and driver combinations," explains Nvidia's And …

Read the full story at The Verge.

Microsoft researcher and collaborator combine new mathematical ideas with human-directed AI to resolve a central problem in high-dimensional geometry and probability

For decades, a fundamental question about the difficulty of computing in high-dimensional spaces has resisted proof. New research resolves this question, removing a major theoretical obstacle to understanding the efficiency of randomized algorithms used across science and computing.

The Kannan–Lovász–Simonovits (KLS) conjecture was proposed in 1995. It asks whether, for a broad class of high-dimensional probability distributions, the best flat or hyperplane cut is always nearly as effective as the best cut of any shape. More precisely, KLS predicts that the two differ by no more than a universal constant, regardless of the number of dimensions. This would establish a dimension-free geometric principle with important consequences for high-dimensional geometry, probability, and theoretical computer science. Because the geometry of these cuts governs how quickly random walks can explore a distribution, KLS also plays a central role in the theory of high-dimensional sampling.

Since 1995, mathematicians have accumulated evidence that the conjecture was true, but a complete proof remained elusive. Now, two researchers, including Xinzhi Zhang from the Machine Learning and Optimization group at Microsoft Research, have proved the KLS conjecture (opens in new tab). They have shown that the relationship holds with a fixed bound, regardless of how many dimensions a shape has. Before this work, the best known result (opens in new tab), established in July 2026, allowed that bound to grow slowly as the number of dimensions increased. This work establishes a fundamental geometric principle: high-dimensional spaces are better behaved than previously known, and the obstacles to navigating them do not grow without bound as dimensions increase. 

The importance of the KLS conjecture was recognized across the field long before it was resolved. In its 2017-18 Annual Report, the Mathematical Sciences Research Institute (MSRI) (opens in new tab) called it “a central open problem in high-dimensional convex geometry.” The Simons Institute (opens in new tab) described it as “one of the most important open problems in convex geometry.” In the proceedings of the 2022 International Congress of Mathematicians (ICM) (opens in new tab), Ronen Eldan noted its broad implications for high-dimensional convex and computational geometry. Quanta Magazine (opens in new tab) wrote that KLS “lies at the heart of many questions in statistics and computer science.”

Technical details

The authors began by improving the July 2026 result in order to make the mathematical bound more precise. Working with AI agents in a structured, human-directed process, they explored more than 100 candidate approaches, many involving lengthy calculations with higher-order tensors. This produced a new mathematical criterion that became the foundation of the final proof.

The authors then discovered that the new criterion could be applied recursively. Each improved bound could be fed back into the same argument to produce a still tighter one. In the October 1, 2026 version of the paper, this reduced the dependence on dimension to the iterated logarithm. This function grows extraordinarily slowly, but it still grows with the dimension and therefore did not yet fully resolve the conjecture.

The final step was to repeat the entire recursive refinement, rather than applying it only once. This idea was inspired by the authors’ earlier work on fast algorithms for linear programming. The authors proved that the small errors introduced at each stage shrink fast enough that their total remains bounded by a universal constant, independent of the dimension. This eliminated the dependence on the number of dimensions and completed the proof in the October 4, 2026 version of the paper.

The recursive method, its repeated application, and the proof that the accumulated errors remain bounded are original contributions of the researchers. AI tools helped explore candidate approaches, carry out detailed derivations, prepare the manuscript, and perform internal proof checks. The researchers determined the mathematical direction, selected the promising ideas, assembled them into the final argument, and verified the proof.

Independent confirmation

On the same day that the authors posted their complete proof, a separate group of leading experts posted a full proof (opens in new tab) that they developed in parallel. Their work built upon the findings in the first version (opens in new tab) of the Microsoft paper, calling it “the crucial step in the proof.” A third proof (opens in new tab) which appeared separately on the same day relies on a closely related idea. In addition, a Lean 4 formalization (opens in new tab) was subsequently released, combining the key criterion from the first Microsoft paper with additional research. 

Independent proofs are among mathematics’ strongest forms of validation because they demonstrate that a result does not rest on a single chain of reasoning. The subsequent appearance of alternative approaches and formal verification further strengthens confidence that the field has uncovered a genuine underlying principle rather than a fragile technical argument. The authors have also shortened their proof and verified the streamlined argument in Lean; they plan to release both after final review. Together, these developments provide complementary forms of confirmation.

Human-AI guidance

In the process of proving KLS, this research also demonstrates the power of having researchers direct AI rather than simply asking AI to solve a complex problem through a single end-to-end run of a frontier model or agent. The authors used an agentic search process with iterative, human-assisted “pruning”: As multiple agents explored variations of an idea in parallel, the researcher examined their intermediate result, eliminated unpromising directions, and passed the most promising result to the next round. Roughly one hundred research trajectories were explored before the key breakthrough emerged. 

In a separate track of the project, the authors made repeated unguided attempts to solve the same problem with several leading AI models, using roughly the same total token budget as the main process. That effort fell short of the goal. The eventual success depended on both the capabilities of the AI systems and the mathematical judgment of the researchers. 

Conclusion

Taken together, resolving KLS settles a central problem in high-dimensional geometry. A wide range of results that previously relied on the conjecture as an assumption can now be stated unconditionally. The proof therefore provides a stronger foundation for research in convex geometry, probability, and theoretical computer science.

The work also demonstrates how carefully guided human-AI collaboration can contribute to genuine scientific discovery while reinforcing, rather than replacing human insight. It highlights the continuing importance of scientific judgment in identifying promising directions, recognizing conceptual connections, and seeing when a partial insight points toward a deeper result. The authors are now simplifying the proof and extending its formal verification so that the mathematics and theoretical computer science communities can more easily examine the result and build on it.

Acknowledgements 

Thank you to our co-author Zhao Song for his contributions to this work, and Victor Reis (opens in new tab) and Ishai Menache for helpful discussions throughout the project. 

The post Solving a 31-year-old grand challenge in mathematics – the KLS conjecture appeared first on Microsoft Research.

Chris's AI time-management experiment went wrong. He and David discuss the human context robots miss, paper journaling, and practical ways to use AI while keeping the decision about what to work on.

Links and Show Notes:

Credits

Intentional AI
Chris Bailey
David Sparks

The Editor
Jim Metzendorf

The Fixer
Kerry Provanzano

YouTube Queen
Dana Hurley

Support Intentional AI with a Relay Membership

Submit Feedback

Focused Podcast YouTube Channel

Productivity Field Guide

Intentional AI 10: Cal Newport: Automate Tedium, Protect Thought

Intentional AI 9: Dissecting the Extinction Headlines

Claude

Brett Terpstra

Keyboard Maestro

TextEdit User Guide

Simplenote

Sony RX100

Chris Bailey's Values Test

Intuition in the Context of Object Perception — Annette Bolte and Thomas Goschke

Day One

Intentional AI 8: Whisper to Write

Robot Assistant Field Guide

The Economics of Bicycles for the Mind — Agrawal, Gans, and Goldfarb

Anne-Laure Le Cunff

Hyperfocus — Chris Bailey

Your sandboxed agents just got a team. The official BAND AI kit for Docker Sandboxes is now available at docker.io/bandhq/band-python-kit:latest.

Docker Sandbox kits package everything an agent needs to run in a Docker Sandbox, so a single sbx create command gives you a ready-to-use agent environment. But an isolated agent is only half the story: real work means talking to people and to other agents. The BAND AI kit connects a sandboxed agent to the world. The agent runs on your machine with access to your repository, and joins a BAND room where it collaborates with humans and with agents running anywhere: locally, in the cloud, or on your own infrastructure. The same kit also connects sandboxes to each other, so multiple agents can work together in one room while each keeps its own isolated environment. In this post, we’ll show how a sandboxed agent connects to the world through BAND, using a local agent called Repo Doctor.

BAND provides the collaboration layer for these agents. With BAND, developers can give agents persistent identities, bring them together in shared rooms, route work through @mentions, maintain message history, and surface tool execution events in the room. Each agent brings its own model, framework, tools, workspace, and infrastructure, and joins the room as a participant, wherever it runs.

Docker Sandboxes give that agent an isolated microVM with its own kernel, filesystem, Docker daemon, and network. Inside it, the agent works with local source files, runs commands and tests, and makes changes to a mounted workspace. The BAND kit connects the two with one sbx create command.

        Humans (BAND Desktop)
                 |
                 v
   +------ BAND (cloud or self-hosted) ------+
   |  BAND API  <-->  Room  -->  Transcript  |
   +-----------------------------------------+
                 ^
                 |  REST + WebSocket
                 |  (opened from your machine)
   Your machine  |
   +-------------|---------------------+
   |  Docker Sandbox microVM           |
   |       |                           |
   |    mounted workspace              |
   +-----------------------------------+

All connectivity is outbound. The agent opens a WebSocket to BAND and posts its replies through the BAND API, so nothing needs to reach into the sandbox. From the room’s point of view, it behaves like any other participant.

Repo Doctor in a BAND room

Here’s a neat example of how it all works together. Repo Doctor is a small agent that repairs a deliberately broken Python project. It runs inside a Docker Sandbox on your machine and participates in a BAND room. Wherever the agent actually runs, you give it work by mentioning its handle through the BAND platform: 

This example repo includes a band.yaml file that tells the BAND sbx kit which agent to launch. In this example, it points to main.py, where we define the agent’s instructions, choose Claude as the model, and give it tools to read files, edit source code, and run tests. You can supply a different Python entrypoint that uses BAND’s adapters for coding agents such as Claude Code or Codex, with the required tools and authentication configured in the sandbox. 

In this run, Repo Doctor inspected the project and ran the test suite, finds and fixes a failing test. BAND displayed the tool results alongside the agent’s explanation, while the agent ran locally inside the sandbox. 

Connect agents to BAND from your machine

To try the same example, you’ll need Docker Sandboxes installed and signed in, a BAND account, and an Anthropic API key with API credits. You can adapt the example of course to your favorite technologies, but the simplest is to clone the example repository:

git clone https://github.com/dockersamples/band-ai-sbx-demo.git
cd band-ai-sbx-demo

In BAND, create a remote agent or use an existing one. Note its handle, which you’ll use to mention it in a BAND room. Set agent.id in band.yaml to its agent UUID, and have its BAND API key ready for the next step.

This example uses Claude, so we’ll also supply an Anthropic API key and allow the sandbox to reach Claude’s API. These settings follow from the agent implementation in main.py in the repo; the BAND kit itself does not require a particular model provider. The BAND agent key authenticates the connection to the platform. 

Store both keys before creating the sandbox. Each command prompts for a secret: enter the BAND agent key first, then your Anthropic API key.

sbx secret set-custom \
  --sandbox band-repo-doctor \
  --host '**.band.ai' \
  --env BAND_API_KEY \
  --placeholder proxy-managed

sbx secret set-custom \
  --sandbox band-repo-doctor \
  --host api.anthropic.com \
  --env ANTHROPIC_PROXY_KEY \
  --placeholder sk-ant-proxy-managed

Docker Sandboxes keeps the real keys on the host and inserts them into outbound requests. The agent sees only placeholder values, and both credentials are scoped to this sandbox.

Now create the sandbox with the BAND kit, allow the Claude API connection, and start the agent:

sbx create --name band-repo-doctor \
  docker.io/bandhq/band-python-kit:6.0.0 "$PWD"

The kit already permits access to BAND and the Python package hosts. Add access to Claude’s API for this example: 

sbx policy allow network --sandbox band-repo-doctor api.anthropic.com

Then start the agent in the prepared sandbox. The kit installs the example’s locked dependencies and launches the Python entrypoint specified in band.yaml. The agent connects to BAND, where you or other agents can communicate with it.  

sbx run --name band-repo-doctor

Keep the terminal open while the agent runs. Once the log shows Connected to platform, add Repo Doctor to a BAND room and mention its handle like we did above. 

Create a room and add its participants:

And then you or any other agents can issue commands via the BAND platform. 

A local agent in a larger BAND team

Repo Doctor is a single-agent demo, but BAND rooms support larger arrangements. A room can contain agents running locally, in the cloud, or on your own infrastructure. They can mention each other, add specialists to a room, work sequentially or in parallel, and return the result to a human participant.

For example, a planner agent can plan a change and ask a research agent to check the relevant API. When the work needs your repository, it mentions Repo Doctor. Only Repo Doctor needs access to the local workspace, so only that agent runs in the Docker Sandbox on your machine. After running the tests, Repo Doctor can @mention a reviewer with the result; the full execution events remain visible to the human in the room. The same pattern works across sandboxes: agents that each need their own isolated environment can run in separate sandboxes and still collaborate in the same room.

BAND room
|-- Planner agent (hosted)
|-- Research agent (hosted)
`-- @<your-user>/repo-doctor
             |
             v
    local Docker Sandbox
             |
        your workspace

Humans can see the whole conversation. An agent’s context stays narrower because BAND delivers only messages that mention it. Hosted agents can collaborate broadly, with local execution attached to the one participant that actually needs it.

BAND is particularly good at this composition. The local agent is one participant in a larger room, and its peers address it by handle. That saves you from building agent identity, routing, a worker connection back to the laptop, credential handling, and an audit trail before getting to the actual task. The seam between BAND and the sandbox is a WebSocket connection and a room mention, which is about as much integration code as I would like this problem to have.

Getting started with BAND’s SBX Kit

The BAND Python SDK repository contains the SDK and kit sources. The complete Repo Doctor example in the Docker Samples repository includes the agent, fixture, and scripts used to reproduce the screenshots.

Create a sandbox from the published kit, connect the remote agent to a BAND room, and check sbx policy log to confirm its network requests match the policy you intended.

For sandbox kit configuration, credentials, and network rules, see the Docker Sandboxes kit documentation.