A full data-structure toolkit
Strings, counters, hashes, lists, sets, sorted sets, streams with consumer groups, and pub/sub, plus probabilistic cardinality and bitmaps, around three hundred operations in all.
‹ qOS
Agent Cache· Forge
In-memory data, on every core.
Forge is an in-memory store rebuilt from a blank page in Rust for hardware with dozens of cores. It runs across all of them instead of one, speaks a lean binary protocol over raw TCP, or shared memory for programs on the same box, and still understands the commands your existing Redis tools already use.
300+ operations, Redis-class
3 transports: TCP, UDP, shared memory
All cores not single-threaded
Why Forge
The fastest stores still run on one core.
Redis and its forks are single-threaded and speak a text protocol designed for 2009-era hardware, so they leave most of a modern server idle and pay parsing cost on every request. Even a client on the same machine has to go through a network socket.
Forge keeps the familiar feature set but removes the structural limits: it uses every core, talks a compact binary protocol, and lets co-located programs skip the network entirely.
Capabilities
What it can do.
Drop-in Redis compatibility
Any existing Redis client or tool, including redis-cli, connects unchanged. The binary protocol is the fast path; Redis is the compatibility path, on one engine.
Three transports, one engine
Binary over TCP for remote clients, UDP for fire-and-forget writes, and a lock-free shared-memory channel for same-machine programs that skips the network stack.
Server-side scripting
Run multi-step logic atomically next to the data with an embedded Lua engine and loadable function libraries.
Optional durability
Off by default for pure speed; switch on a checksummed write-ahead log plus background snapshots for crash recovery, with selectable fsync strength.
Secondary indexes
B-tree indexes on fields give exact-match and range lookups beyond the primary key, something standard Redis cannot do natively.
Transactions and queues
Optimistic-locking transactions and blocking pops for safe queues and work distribution.
Built-in web Studio
A management UI with a data browser, console, live dashboard, and Lua editor, plus an HTTP API and Prometheus metrics, embedded in the binary.
Built different
Why it is not just another cache.
-
Multi-threaded from line one
A work-stealing pool puts a thread on every core with per-thread sharding, where Redis and Valkey inherit a single-threaded design. It scales with cores instead of around them.
-
Shared memory for local clients
Same-machine programs talk over a lock-free shared-memory channel and skip syscalls and serialization entirely, a transport Redis simply does not have. A natural fit for an agent and its tools sharing one sandbox.
-
A binary protocol with no parsing
Fixed-layout frames keyed by a number, with native multiplexing over one connection, instead of text commands and pipelining workarounds.
-
Rust, no GC pauses
Memory-safe with lock-free structures and no garbage collector, so tail latency stays predictable instead of stalling.
-
Runs as a microVM image
A unikernel build boots Forge straight as a microVM with env-var config, made for per-sandbox agent infrastructure.
By the numbers
Engineered for microsecond access.
Architectural design targets, not yet independently benchmarked.
Sub-µsshared-memory path (target)
Single-µsTCP path (target)
Lua 5.4atomic server-side scripts
WAL + snapshotoptional durability
Agent-first
The hot-state layer for every sandbox.
Forge is where an agent platform keeps the state it touches constantly: session routing, idempotency keys, rate limits, short-lived locks, and working memory, all at microsecond access instead of a database round-trip. Because it runs as a microVM and offers a same-machine shared-memory channel, an agent reads and writes state with no network hop, and atomic transactions keep multi-step changes race-free.
- Per-sandbox state with TTL expiry, so abandoned sessions clean themselves up.
- Atomic counters and ephemeral locks over shared memory to coordinate concurrent actions.
- Pub/sub and durable streams for fan-out events and agent work queues.
Put Agent Cache to work.
See HQ running in your own Slack or Teams, on the operating system we built for agents.