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.
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.
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.
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.
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.
After an outage an agent prepares a grant of potions. The reviewer sees one player would get fifty and sends it back. Meanwhile the game kept writing, and the agent's "3 + 5 = 8" is no longer true: the merge stops and names the key. Walkthrough
An agent reads tickets and proposes account credits, one branch per ticket. One is approved, one is beyond what the desk may give and is left alone. Later: "who credited customer 31, and who signed it off?" and "delete my data". Walkthrough
A new checkout goes to a share of visitors, each stage approved by name. At 50% errors rise: that one change is taken back, and a setting someone else changed afterwards stays as it is. Walkthrough
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.
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.
plain-async table lost only the last puts it had answered early, as it
says it may.
A person gives the agent a token for one branch, some keys, a purpose and an expiry.
The agent writes to its branch, with a reason. Production does not change.
A person picks one from the list of changes waiting and reads its diff.
Approved, it enters production with the approver's name. Rejected, it is kept with the reason.
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.
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.
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.
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
127.0.0.1 only, as above. Reads need no
token yet, and nothing on the connection is encrypted.
umbrachyx mcp) or the
Redis protocol, with a token a person issued for one branch, some keys, a purpose
and an expiry.
UMBRA.* commands may still change.