The Missing Feature

Pick Jett. You want your clean, sharp Jett skins. Pick Killjoy next game. Now you want your cyberpunk-y Killjoy skins. Pick Reyna. Different vibe again.

Every Valorant player who owns more than a handful of skins has wished for the same thing: skins that automatically change based on the agent you pick. Your Jett loadout, your Killjoy loadout, your Reyna loadout — each one waiting for you the moment you lock in.

The community has been asking for per-agent skin presets for years. Browse the Valorant subreddit and you'll find dozens of threads requesting exactly this. Unfortunately, Riot has stated they don't currently plan to add it.

So I decided to build it myself.

Prior Art

Before writing a single line of code, I did some research to see what already existed. The most prominent project in this space is valorant-inventory-manager by colinhartigan. It's a great project and does a lot of useful things — but it doesn't do the one thing I actually wanted: automatically swap your skin loadout based on the agent you pick.

That meant I'd have to figure out the technical side myself.

The Key Discovery

Digging through the code of existing tools and poking at Valorant's local client APIs, I discovered something interesting: you can technically change skins during agent selection. The client accepts loadout modifications at that point in the match lifecycle, which is exactly the window you need to make per-agent skins feel native.

That was the unlock. If I could:

1. Detect when the player enters agent select
2. Detect which agent they locked in
3. Push the loadout tied to that agent to the client

...then I'd have agent-bound skins — the feature Riot never shipped.

Prototype #1: Python

The first prototype was a quick-and-dirty Python app: valorant_loadouts_python. It proved the concept worked — when I picked an agent, my skins changed to match. It actually felt magical the first time it triggered automatically.

But it was a terrible UI, no easy way to assign skins to agents visually, no good install story (I uploaded the installer to the repository itself lol). It worked and when I announced it on Reddit, people actually liked and used it but it was just a terrible user experience without a way to change existing presets and so much more.

Prototype #2: ValoVault

So I rebuilt it properly. Meet ValoVault.

The headline feature is exactly what the community has been begging for: bind a skin loadout to each agent, and ValoVault swaps them in automatically during agent select. Lock in Jett → Jett skins. Lock in Reyna → Reyna skins. No clicking, no menus, no thinking about it.

As a bonus, you can also save multiple named presets and switch between them manually — handy for "tryhard vs. for fun" setups, or for sharing builds with friends — but the per-agent assignment is the star of the show.

Architecture

The architecture ended up being a bit more interesting than a typical desktop app:

• A Go API wrapper I wrote from scratch for the Valorant local client APIs
• A Go sidecar backend that runs alongside the UI, watches the game state, and pushes loadouts at the right moment
• A Next.js frontend for the actual interface — skin grids, agent assignment, preset management
• Tauri wrapping the whole thing into a lightweight native desktop app

Why this stack?

• Go for the backend — concurrency primitives are perfect for polling the game client and reacting to agent select events. A single static binary is easy to ship as a sidecar.
• Next.js for the UI — I wanted a real component-driven UI with proper state management, not a glorified HTML page. The skin grid alone has thousands of images to handle gracefully.
• Tauri instead of Electron — way smaller bundle, way less RAM, and the Rust shell plays nicely with the Go sidecar pattern.

The Next.js app talks to the Go backend over HTTP on localhost, and the Go backend talks to the Valorant client. Clean separation, easy to develop each piece independently.

What ValoVault Can Do

• Assign a skin loadout to every agent and have it applied automatically when you lock in
• Save additional named loadout presets for manual swapping
• Browse your entire skin inventory with levels, chromas, and gun buddies
• Pick variants and buddies per-weapon, per-preset

It's open source, Apache-2.0 licensed, and works on Windows.

What's Next

If you want to try it, grab a release from the GitHub repo. Contributions, bug reports, and feature requests are all welcome.

And if you're a Riot dev reading this — please, just ship per-agent loadouts natively. I'd happily archive the repo. 🙂