Three-layer brain architecture with task classification, model routing, persistent memory, and a full tool system. Plugin-driven extensibility from the ground up.
One binary that owns its inference server and runs contained on hardware you own. The context engine inside it, Keel, decides what enters the model's window, what that costs, and what gets cleaned up after. Code was the first work it was pointed at, not the limit of what it holds.
Inference to storage. Every library built and owned by Grimvane.
03The armory
Projects
CUBEE
games
CUBEE
A minimalist 3D puzzle game with rolling cube mechanics, face-relative movement, and procedurally generated paths. Built in Godot with a modular event-driven architecture.
An agent harness that owns the inference server it runs on. One binary on hardware you own, built as a context engine first, deciding what enters the model's window and what that costs.
An experimental convergence of artificial intelligence and interactive entertainment. Dynamic narrative systems, emergent behavior, and procedural world-building, integrated at the engine level.
A budget tracking application built around a compass navigation metaphor. Four-direction financial management across income, debt, investments, and goals, with daily snapshots, temporal analytics, and delta-optimized storage.
The marketing and blog site for CUBEE, featuring an interactive 3D rolling cube visualization, procedurally seeded paths, and a blog discovery system. Built with Three.js and deployed to the edge.
Client website for a Twitch creator. Live stream integration, commission intake with budget and file handling, and a vanilla frontend with no build step.
One studio. No investors. Everything built from scratch, everything owned in full.
AI assistants, puzzle games, security research, and client work — connected by the
same standards and the same person behind each one.
Grimvane is a software studio that builds AI tools, games, and the shared
infrastructure underneath both. We design every layer ourselves, from graph
databases and vector memory to game engines and marketing sites.
The work spans domains on purpose. The same libraries powering our AI assistant
generate overworld maps in our games. The same design philosophy that shapes a
data pipeline shapes a card crafting system. Building across boundaries is how
we find ideas that only exist at the intersection.
What We Care About
Every project starts from the same question: what should this be if we had no
constraints except taste? Then we work backward to something we can actually ship,
without losing the answer.
Build the thing that should exist.
Data-rich, ad-free, designed for people who care about the details. Quality
over reach. Depth over breadth.
Own the architecture.
Features can be replicated. The structural decisions underneath them -- how systems
connect, what constraints are chosen, where the foundation sits -- those compound
over time into something that can only be built from the ground up.
Floor, not ceiling.
Build platforms that establish a standard of quality and then get out of the way.
Enable things that were previously impossible without constraining what is possible.
Refuse the easy answer.
The first solution is almost always the conventional one. Convention optimizes for
safety, not quality. The work worth doing usually starts where the obvious path ends.
Who We Are
Grimvane was founded by Christopher Whitworth. The studio grew out of a simple
conviction: if you care enough about how something is built, the result speaks
for itself.
The name is the philosophy. The work is the proof.
Client website for a Twitch creator. Live stream integration, commission intake with budget and file handling, and a vanilla frontend with no build step.
HTML/CSS/JSNode.jsExpressTwitch APIDockerFly.io
Archived. The site is no longer live.
Vector memory library. Store text as vectors, search by meaning. Pluggable embedders, pluggable backends, zero opinions about your application.
PythonNumPyVector Search
Camellia is Grimvane’s shared vector memory library. It embeds text into vectors, stores them in a backend of your choice, and finds similar entries by meaning — not keywords. It has no concept of NPCs, documents, sessions, or any domain. It stores vectors and searches them.
Lightest usage needs nothing beyond Python and NumPy. Full usage adds GPU embeddings via Crucible, persistent storage via SQLite or PostgreSQL, and optional memory lifecycle with decay and consolidation.
A budget tracking application built around a compass navigation metaphor. Four-direction financial management across income, debt, investments, and goals, with daily snapshots, temporal analytics, and delta-optimized storage.
ReactTypeScriptNode.jsExpressSQLiteDrizzle ORMPWA
CashCompass organizes personal finance around a compass. West is income, South is bad debt, East is good debt and charitable giving, North is goals, with a “True North” goal set above the rest.
Built as a full-stack application with a two-tier user system (users to profiles), multi-device network access, and a Progressive Web App shell installable on any platform. Daily snapshots use a delta-based optimization that reduces storage by 96.5%, tracking financial state over time with trend visualization.
Features include interest calculations on debts, goal progress tracking, whole-database backups with retention policies, per-profile JSON/CSV export, and a glassmorphic bento grid interface.
A modular, plugin-based AI assistant built on three core layers, brain, plugins, and configuration. Task classification, model routing, persistent memory, and a full tool system.
PythonPlugin ArchitectureLLM Integration
Corvath is a modular AI assistant designed around composability. Its architecture splits into three core layers: a Brain that handles reasoning and task classification, a Plugin system for extensible capabilities, and a Configuration layer for model routing and behavior control.
Key capabilities include multi-model support through a plugin architecture, persistent memory backends, a tool system for real-world actions, security sandboxing, and audit logging. Currently in active development with Phase 2 complete.
Proprietary local inference engine. Parses GGUF model weights, runs transformer computation on GPU, generates text. No wrappers, no third-party servers.
PythonCUDAGGUF
Crucible is Grimvane’s from-scratch LLM inference engine. It reads GGUF model files directly, implements the transformer forward pass against CUDA via CuPy, and handles tokenization and sampling — without wrapping Ollama, llama.cpp, vLLM, or any other inference framework.
Designed for single-GPU local deployment. Primary consumer is Project Blackbox, but any Grimvane project needing local model inference imports Crucible.
A minimalist 3D puzzle game with rolling cube mechanics, face-relative movement, and procedurally generated paths. Built in Godot with a modular event-driven architecture.
Godot 4GDScript
CUBEE is a 3D puzzle game centered on a rolling cube that traverses tile-based environments. Movement is face-relative — each roll changes which face is down, altering how the cube interacts with the world.
Features include 90-degree tile transitions, multiple game modes, procedurally seeded paths, and a modular event-driven architecture built during a ground-up refactor. The web presence at playcubee.com features an interactive Three.js demo with the cube in action.
Structured storage library. Schema-driven collections, field-based queries, filter operators. Zero opinions about your application.
PythonSchema ValidationQuery Filtering
Dahlia is Grimvane’s structured storage library. Define a schema, insert records, query by field values with filter operators. Three pluggable backends: in-memory, SQLite, PostgreSQL. Same API regardless of backend. No concept of what your records represent.
Schema-Driven Design
Every collection has a schema defined up front. Dahlia validates on write, not at query time. Bad data is caught at the boundary, before it reaches application logic.
Schemas can be plain dicts or Python dataclasses. Both work the same way:
Operators: $eq, $ne, $gt, $gte, $lt, $lte, $contains, $in, $not_in. Each one is a single conditional under the hood, no query language to parse.
Pluggable Backends
Backend
Dependency
Use Case
memory
None
Testing, ephemeral data, embedded runtimes
sqlite
Python stdlib
Single-file persistence, desktop apps
postgres
psycopg
Server deployments, large datasets
Switching backends is a one-line change. The in-memory backend ports to other languages with zero dependencies, which is how Dahlia travels to GDScript inside Godot.
Consumers
Project
Usage
Corvath
Structured data storage for session state and tool configuration
Local AI chat where the characters remember. Runs on your own hardware against your own models, with no account and nothing leaving the machine.
PythonFastAPITaurillama.cppMLX
Hearth is a self-hosted chat application built around characters rather than
around a single assistant. Character cards define who someone is, a scene
layer lets several of them share a conversation with declared perception and
speaker attribution, and retrieval grounds replies in documents you supply.
The problem it exists to solve is memory. Every chat product eventually runs
out of context window, and when it does the character starts contradicting
itself. Hearth keeps a separate character memory rather than relying on the
window. Measured against a held-out set of facts at 400 turns on an 8B model,
the context window alone recovered one of seven and the memory system
recovered seven of seven.
Backends are swappable. llama.cpp covers NVIDIA, AMD and CPU, MLX covers
Apple Silicon, and Crucible plugs in where it is available. Every pass, guard
decision and retrieval candidate is traced per turn, so a regression in answer
quality can be attributed rather than guessed at.
The marketing and blog site for CUBEE, featuring an interactive 3D rolling cube visualization, procedurally seeded paths, and a blog discovery system. Built with Three.js and deployed to the edge.
TypeScriptViteThree.jsNginxDockerFly.io
The web presence for CUBEE, built as a modular TypeScript application with an interactive Three.js demo at its center. Visitors can watch the cube roll through procedurally generated paths seeded for reproducibility, alongside blog posts and embedded video content.
Architecture follows strict separation of concerns — config, services, entities, systems, and UI layers — with full SEO coverage including Open Graph, Twitter Cards, and Schema.org structured data. Security hardened with CSP, HSTS, XSS protection, and frame protection headers.
Client website for a VTuber and graphic designer.
AstroNodeFly.ioDockerSharp
Streams, design work and a shop in one place.
An agent harness that owns the inference server it runs on. One binary on hardware you own, built as a context engine first, deciding what enters the model's window and what that costs.
Gollama.cppMLXSQLite
Shoal is a local AI coding platform. It runs coding tools against on-device models with no API keys, no cloud calls, and no telemetry. Crucible for direct GPU computation, MLX on Apple Silicon, llama.cpp on NVIDIA/AMD/CPU, with optional frontier API mooring for tasks that exceed local capability.
The system uses a multi-dock architecture where different coding assistants connect to a shared local inference backend. Keel Dock is a Go-based coding assistant with a terminal UI, architecture indexing, and autonomous refactoring. Pilot Dock connects to frontier APIs (Anthropic, OpenAI) as a supplementary reasoning backend. Claude Dock runs Claude Code CLI against local models via an Anthropic-to-OpenAI translation proxy. KV cache compression (KVTC) achieves 20x compression for efficient context retention across long sessions.
Client website for a variety streamer and artist.
AstroNodeFly.ioDockerSharp
He draws the model he streams in, along with his emotes, badges and overlay.
Graph database library. Nodes, edges, traversal, multi-head activation, compressed awareness. Zero opinions about your application.
PythonGraph TheoryPCA
Wisteria is Grimvane’s graph database library. Store typed nodes and directed edges with metadata. Query neighbors, find shortest paths, extract subgraphs, traverse to arbitrary depth. Three pluggable backends: in-memory, SQLite, PostgreSQL. Same API regardless of backend.
What sets Wisteria apart is what sits on top of the core graph engine.
Multi-Head Activation
Wisteria doesn’t just tell you what’s connected to something. It tells you what’s relevant to something, and the answer changes based on what you’re doing.
Each “head” is an independent perspective defined by edge-type families. A dependency head follows consumes and depends-on edges. An organizational head follows contains edges. A presentation head follows website-for and markets edges. Each head produces its own relevance map.
A query-context weight vector controls the mix. Debugging weights dependencies high and marketing low. Business planning inverts it. Same graph, different lens, different ranking.
Compressed Awareness
Derived from KVTC (KV Cache Transform Coding), Wisteria applies transform coding to graph node activation states. PCA decorrelation identifies redundancy in the activation space. Dynamic programming allocates precision per component. Nodes are stored in three tiers:
Hot — attention sinks and the current working set, full resolution
Warm — recently active, PCA-compressed
Cold — inactive, heavily compressed or zero-bit
Decay is compression. Rejuvenation is decompression. Information is never destroyed, only stored at varying fidelity. When a compressed node becomes relevant again, it decompresses — no recomputation needed.
Why It Matters
An 8B parameter model cannot reliably reason through a multi-hop graph with weighted traversal. But it can call engine.activate("corvath") and read a ranked list. The library does the precise computation. The model interprets results and takes action.
Wisteria is cognitive infrastructure. Necessary for constrained models. Superior for capable ones.
