Umbrachyx

Darkness is faster than light.
The database that remembers the past.

Your data was changed, and nobody can say when, by whom, or why.
Here every change is kept, with who made it, why, and who approved it.
Reads answer in tens of microseconds, even while writes keep coming.

If the current value is the light, its history is the shadow that was there before the light arrived.

Start with Docker GitHub Linux / macOS / Windows・MIT
A terminal. The diff of an AI agent's change shows one player would get 50 potions. The corrected change is merged with the name of the person who approved it. The history of that value then shows each change with who made it, why, and who approved.
Afterwards, the value itself says who gave player 9 what, why, and who signed it off. The fifty an AI agent first wrote never reached production: its writes wait on a branch until a person approves the diff. The commands and their output are shortened from the game inventory example, which the tests run as written on every change; a commit's id differs on every run.

WHY IT HAPPENS

A database holds only the current value, and a write is production the moment it lands. Keeping the past was slow, so it was left to logs and backups → now AI agents write too: fast, many, sometimes wrong → by the time someone notices, the old value and the reason are gone.

Here the history is not a log beside the data; it is how the data is held, in memory, so asking a value where it came from costs about what reading it does. And narrowing an agent's permissions by configuration fails with one wrong setting, so an agent has no way to write to production to begin with. The token an agent is given names its branch; it cannot write anywhere else, and it cannot approve. (The one exception is a table declared to keep no history: it has no branches, and there the token decides only which keys.) What a hijacked agent was tested not to be able to do is listed with the tests.

WHAT IT IS

Umbrachyx is an in-memory database that keeps every change as history. Each value knows when it changed, from what to what, who changed it, why, and who approved the change; and the history can be branched, diffed, merged and undone, the way git handles files. It speaks the Redis protocol, so existing clients work, and agents connect through MCP.

QUESTIONS IT CAN ANSWER

Four walkthroughs, each run by the tests as written: a game's inventory, a support desk, settings rolled out in stages and five questions about a game's data.

WHERE IT FITS: THREE MADE-UP CASES

Nobody's production is described here: the three cases are invented, with made-up data. Each one is a walkthrough whose commands the tests run exactly as written.

SPEED, WITH THE ROWS WHERE IT LOSES

Measured next to Valkey on the same AWS machine (EC2 m6id.xlarge, Tokyo, its local NVMe disk). On both sides a write is synced to disk before it is acknowledged (Valkey with appendfsync always). 32-byte values, a million keys, synthetic data.

A second Umbrachyx Valkey
Reads while 50 clients keep writing 24,667 1,758 about 14× more
Reads, one client 54,377 37,216 about 1.5× more
Synced writes, one client 8,832 6,268 about 1.4× more
Reads, 50 clients 149,477 151,745 1% fewer
Synced writes, 64 clients 43,649 94,473 about 2.2× fewer
Synced writes, 256 clients 56,577 112,360 about 2.0× fewer
Synced writes, 50 clients sending 64 at a time 84,221 626,959 about 7.4× fewer
Memory for each overwrite about 655 bytes about 16 bytes about 40× more

Every row is the median of three runs on 2026-11-17, and every Umbrachyx row is with all of the history kept. It is not a faster Valkey. With many clients writing at once, and in memory, it is clearly behind: that is what keeping all of the history costs. The raw output, the machine and the steps are in bench/results, and every table, with PostgreSQL and Dolt, is in the README.

Tables that keep no history

A table can be declared to keep only its current values, as Valkey does: no history, no branches, no review. plain still syncs every write before it answers, and is set against appendfsync always. plain-async answers first and syncs within a second, and is set against Valkey's default, appendfsync everysec.

A second Plain Valkey always Plain-async Valkey everysec
95% reads, 5% writes, 50 clients 162,179 81,269 170,792 106,042
50% reads, 50% writes, 50 clients 124,003 72,454 156,246 100,182
Writes, one client 10,680 6,268 29,061 34,554
Writes, 64 clients 90,050 94,473 106,838 156,495
Writes, 50 clients sending 64 at a time 540,687 626,959 572,082 638,570

The same machine and day. With reads in the load, both kinds are ahead of Valkey. Writes alone, a plain-async table is behind on every row, and a plain table from 64 clients up. Starting again after five million writes takes 3.3 seconds with a plain table and 57.5 with the history kept.

Robustness

HOW A CHANGE REACHES PRODUCTION

WITH DBBOARD

dbboard is a desktop database viewer from the same author. It connects to umbrachyx serve the way it connects to a Redis server, and shows what the terminal commands print:

Nothing in this is special to dbboard. The history is asked for with UMBRA.* commands over the Redis protocol, and any client that speaks it can send them.

WHERE IT IS GOING

It starts from the history of every value and memory speed. Where it is going is a database an AI agent would choose to work against. An agent keeps no memory between sessions, writes from what it read a while ago, retries, and pays for every byte it reads. So the measure is less operations a second than how cheap one round of read, try and check is, and how cheap a mistake is.

What people ask of a database is what the past taught them: keep the history, be fast, count it in operations a second. That is what this one is held to first, in the table above. The second yardstick came from the AI agent the project is built with. Asked to write this page, it opened with a write nobody had looked at and a branch where being wrong costs nothing; asked why, it said it is the one who writes. Both yardsticks are kept: the old one says how fast, the new one says how cheaply an agent gets to a right answer.

What comes next, in this order

  1. Faster writes to tables that keep no history, where it is still behind Valkey when many clients only write.
  2. A cheaper check of an agent's token on every write.
  3. A log that does not grow for ever: dropping what was overwritten, keeping history for a set time, keys that expire.
  4. Read-only followers on other machines, and a backup tool.
  5. Writes that carry what the agent assumed ("set it to 8 if it is still 3"), and a write that counts once when sent twice.

No dates: the order may change with what the measurements say. What is being worked on is in the issues, and what each version brought in the releases.

The whole list is in the concept; for an agent reading this site there is llms.txt.

START

The server alone, in Docker, with its log on a volume. The image is for amd64 and arm64; what each version holds is on the releases page.

$ docker run -d --name umbrachyx -p 127.0.0.1:6380:6380 -v umbrachyx-data:/data ghcr.io/meta-taro/umbrachyx
$ valkey-cli -p 6380 set player/42/gems 100
OK
$ valkey-cli -p 6380 umbra.history app player/42/gems
# the value, the commit's id, when, who, why and who approved, as JSON

QUESTIONS PEOPLE ASK

WHAT IT CANNOT DO YET