If you watch GitHub trends you have probably seen the pattern. For two years every week was a new foundation model, a new fine tune, a new demo that did one cool trick once. That era ended. This month every single trending ML and developer tool is infrastructure. None of them generate text. None of them make pretty pictures. All of them fix the boring, expensive, painful problems that everyone building real AI systems is hitting right now.

The quiet infrastructure shift

Nobody is bragging about this on Twitter. Nobody is making viral demo videos. But over the last 90 days the entire stack for production AI has been rewritten from the bottom up.

Every project in this list follows the same pattern. They take something that every team was already building badly, in house, over and over again. They extract it into a standalone, composable layer. They make it vendor neutral. They publish reproducible benchmarks.

This is good. This is how maturing industries work. We stop building everything from scratch. We agree on standard components.

LMCache: KV cache stops being an implementation detail

For the last three years KV cache was the thing you never talked about. It was a hidden internal state inside every inference server. If your server crashed you lost it. If you scaled out you recomputed it for every instance. If you ran the same prompt ten times you paid for the same prefill ten times.

LMCache changes this. It pulls KV cache out of the inference engine entirely and turns it into a first class, reusable resource.

This is not a minor optimization. For agent workloads, multi turn conversations and RAG, LMCache reduces time to first token by 60-90% and improves throughput by 2.7x on real production traffic. It works with vLLM, SGLang, TensorRT-LLM. It runs on NVIDIA, AMD, Arm, Ascend. It offloads cache to CPU memory, SSD, Redis, S3. It can transfer precomputed cache directly from prefill workers to decode workers over RDMA.

As of May 2026 NVIDIA Dynamo integrates LMCache natively. Cohere runs it in production. It joined the PyTorch Foundation last October. This is not an experimental research project. This is rapidly becoming the standard layer that every LLM deployment will run on top of.

There are tradeoffs. Non-prefix reuse adds 1-2% quality overhead. The multiprocess architecture adds ~1ms latency per request. For very short single shot prompts you will not see gains. For every other workload you will wonder how you ever ran inference without it.

code-review-graph: We finally fixed AI context waste

This is the most important tool released in the last six months. Every single person using an AI coding assistant is wasting 95% of their tokens.

When you ask Cursor or Claude Code a question about your codebase they do exactly what you would do if you were lazy. They grep for keywords. They pull in 10 random files. They ignore 90% of the actual dependencies. They hallucinate. They get the answer wrong. And you pay for every single token they read.

code-review-graph fixes this. It parses your entire codebase into a structural graph using Tree-sitter. It maps every function, every call, every dependency, every test. When you ask a question it traverses this graph and returns exactly the minimum set of code the model needs to see.

The numbers are not exaggerated. On FastAPI the median token reduction is 528x. Across 6 real world repos the median reduction is 82x. That means you pay 1.2% of the token cost you were paying before. And the answers are better.

It works with every major AI coding assistant. It installs with one command. It updates incrementally in under 2 seconds for most repos. It runs entirely locally. No code leaves your machine.

There are limitations. For single line changes the graph overhead can be larger than just reading the file. Flow detection is still weak for JavaScript and Go. Precision averages 58%: it will always prefer to include an extra file rather than miss a dependency. That is the correct tradeoff.

This is the first tool that actually delivers on the promise of AI coding assistants without bankrupting your OpenAI bill. Every team should install this this week.

aisuite: Andrew Ng released the agent library everyone wanted

Everyone and their dog has released an agent framework. Almost all of them are unusable garbage. They are over abstracted. They lock you into one provider. They require 17 dependencies. They break every two weeks.

aisuite is different. It does exactly two things, and it does them well.

First it provides a single OpenAI compatible chat completions API across every major LLM provider. Swap OpenAI for Anthropic for Ollama by changing one string. No other changes required.

Second it implements minimal, opinionated tool calling and agent execution. You pass plain Python functions. It generates schemas. It runs the loop. It stops when it is done. No magic. No hidden state. No forced abstractions.

That is it. That is the entire library.

It supports MCP natively. It has tool approval policies. It has state persistence. It has proper tracing. It is 100% MIT licensed.

This is the agent library that 90% of teams have been trying to build internally for the last year. You can stop now.

SkyPilot: The default orchestrator for AI workloads

If you are running any AI workload larger than a laptop you should be using SkyPilot.

SkyPilot solves one simple problem. There are 20 different cloud providers selling GPUs. None of them have consistent APIs. None of them have reliable capacity. Prices vary by 7x between providers for identical hardware.

SkyPilot gives you one interface to run jobs on any of them. You write a single YAML file describing your task. SkyPilot finds the cheapest available GPU anywhere. It provisions the instance. It syncs your code. It runs the job. It cleans up when it is done. It fails over automatically if one provider is out of capacity.

It works with AWS, GCP, Azure, CoreWeave, Lambda, RunPod and 17 other providers. It works with your existing Kubernetes and Slurm clusters. It requires zero code changes to your existing workloads.

Shopify runs all their AI training on SkyPilot. Teams are using it to run hundreds of agent workers in parallel. This is no longer a nice to have. This is the standard way to run AI workloads at any reasonable scale.

Browser Use: Agents finally get a good browser harness

Agents were terrible at using the web. Not because the models were bad. Because every browser harness was garbage. They missed elements. They clicked the wrong thing. They crashed constantly. They leaked memory.

Browser Use fixes this. It has a new Rust core. It implements proper element detection. It has recovery loops. It handles authentication correctly. It has proper stealth fingerprinting.

It works with GPT, Claude, Gemini and their own optimized model. It installs with one command. It integrates natively as a skill for Claude Code and Cursor.

This is the first browser automation library that actually works reliably for unstructured agent tasks. It will not complete every task. It will still fail on complex flows. But it works correctly 70% of the time, which is 65% better than every other library that existed last month.

The boring tools that still matter

Not every trending tool is shiny new. This week scikit-learn, ansible, pypdf and azure-cli are all in the top 30.

This is not a mistake. All of these tools are 10+ years old. All of them do one job extremely well. All of them have stable APIs. All of them will still work exactly the same way in 5 years.

While everyone was building agent demos these are the tools that actual production systems run on. You will use more lines of scikit-learn code in any real ML system than all LLM libraries combined.

Do not sleep on boring software. Boring software works.

What this trend tells us

We have passed the peak of foundation model hype. The race is no longer who can train the biggest model. The race is now who can run models cheaply, reliably and efficiently.

Every single one of these tools exists because people are no longer running demos. They are running production systems that have to make money. They care about cost. They care about latency. They care about reliability. They care about not wasting tokens.

This is healthy. This is what a real industry looks like.

What you should deploy this week

Install these right now:

1. code-review-graph. It will pay for itself in saved tokens by the end of the day.
2. LMCache if you run any LLM inference.
3. aisuite for all new agent code.
4. SkyPilot if you ever rent a GPU.

Skip the rest for now. Browser Use is great but still beta. Reflex is nice but not critical. Everything else you already know about.

Closing observations

None of these tools are revolutionary. None of them do something that nobody has ever done before.

That is the point.

Good infrastructure is not revolutionary. Good infrastructure is boring. Good infrastructure solves a problem everyone has, and then gets out of your way.

That is what all of these tools do. That is why they are trending. That is why they will still be around in 5 years.

We are finally done building toys. We are now building the actual industry.