I write backend infrastructure: digital twins, distributed runtimes, agent knowledge graphs. Most of my time goes on write paths, service lifecycle, and the seams between systems, which is where things actually break.
I wrote Ultimate Backend and Flutter Unity Widget, which is how most people know me. Currently: Forge, Fabriq and Cortex, plus the data layer under industrial twins.
What an agent reads, infers or is told, turned into something that outlives the conversation it happened in.
Every long-running agent I have built hits the same wall somewhere around turn two hundred. The transcript is mostly resolved chatter by then, the three facts that matter are buried in the middle of it, and token spend is scaling with history instead of relevance. Cortex handles the reasoning side, with bounded working memory, personas and checkpoints. KGKit handles what survives the episode: typed claims with the observation that produced them still attached, written as graph edges a later contradiction can find and revise.
CortexWeaveNexusSentinelEnter the field P/02Backend runtimes, gateways and schedulers for work that runs on more than one machine.
I have written four backend frameworks: Ultimate and North in Rust, Ultimate Backend in TypeScript, and Forge in Go. Each taught me the same thing in a different accent. Routing and handler signatures are the easy part. What costs you is lifecycle: what starts before what, what happens to in-flight requests during a deploy, how a dependency reports that it is unhealthy without taking the process down with it, and who owns the shutdown ordering when six extensions all hold connections.
ForgeDispatchOctopusBastionCtrlplaneFARPEnter the field P/03Software that keeps a live model of something physical, a plant or a fleet or a building, and can still tell you what it believed at four o’clock last Tuesday.
Most of the difficulty sits in the write path. Sensors go offline and backfill hours later. The same reading arrives twice from two collectors configured for redundancy. A gateway buffers for a day and then floods you. The tempting fix is to interpolate across the gap, which produces a chart that looks correct and is not. I work on the layers underneath: Fabriq is the transactional write path, Grove is the storage underneath that, and KGKit turns an asset register that four systems disagree about into a graph you can actually ask questions of.
FabriqGroveEnter the fieldI ship |primitives|. Write paths, runtimes, auth layers, job queues, the code that decides what starts before what and what happens to it during a deploy. It is the part of a product nobody screenshots and every product depends on, and it is most of what I have spent seven years on.
A multi-tenant SaaS starter on NestJS: microservices behind Apollo Federation, CQRS backed by EventStoreDB, tenant resolution, billing and authentication already wired to each other. I wrote it because I kept rebuilding the same first two weeks of every project, and it is still the repository most people know me from.
A Flutter widget that hosts a Unity player and passes messages both ways. It started as a weekend attempt to put a 3D configurator inside a Flutter app and became the package most people use for that. Six years and several thousand issues later, GameFramework is the rewrite.
A working ARKit scene driven by Unity inside a Flutter app. Written mostly as a reply to the same question turning up in the widget’s issue tracker every week.
A NestJS CQRS module that speaks to EventStoreDB, with persistent subscriptions, catch-up subscriptions, and the plumbing that makes @nestjs/cqrs durable. Pulled out of Ultimate Backend once people started asking for only that part.
The rewrite of Flutter Unity Widget, as a Dart workspace with one API and a plugin per engine. Unity works today; Unreal is in progress. Typed messaging in both directions, automatic pause, resume and destroy on Flutter lifecycle events, and builds for Android, iOS, macOS, Windows and Linux.
Authentication for Go with every method as a plugin: password, social OAuth2, magic links, passkeys, TOTP and SMS second factors, API keys, SAML. Users, sessions, organizations, teams, RBAC and device tracking sit in the core; you compile in the methods you actually use. Ships with a dashboard.
An opinionated Go framework: DI container, router, layered config, health checks, migrations and ordered shutdown, plus around twenty extensions you switch on when you need them: Postgres and Mongo, Kafka, MQTT, gRPC, GraphQL, WebRTC, Raft consensus, MCP. `forge init` scaffolds, `forge dev` hot-reloads. Everything else at xraph is built on it.
One write path for applications that outgrew a single database. A command commits state, a versioned event and an outbox row in the same Postgres transaction; a leader-elected relay publishes to Redis Streams; the graph (FalkorDB) and search (Elasticsearch) projections are rebuilt from that log rather than written to directly. Tenancy is structural, using row level security, a graph per tenant and index routing, rather than a WHERE clause you can forget.
An agent framework that describes an agent the way you would describe a colleague: what they can do, how they think, how they talk, what they notice, and what they habitually do when something happens. Runs, steps and tool calls are tracked end to end, checkpoints pause a run for human approval, and memory is scoped per agent per tenant.
A gateway in Rust that builds its own routing table. Services publish a FARP manifest carrying their OpenAPI, gRPC and GraphQL schemas; Octopus finds them over mDNS, Consul, Kubernetes or DNS and derives routes as instances appear and disappear. Static config works too, and the two modes run side by side.
Agent runtimes, retrieval, knowledge graphs, gateways, evaluation and content safety, written in Go and composed as libraries rather than services.
6 projects↗Live models of physical systems: ingestion, state, history, and the ability to rebuild any past moment from the events that produced it.
1 projects↗The Go framework everything else here sits on, plus the gateways, job engines and lifecycle managers around it.
15 projects↗Authentication, authorization, secrets, API keys and tamper-evident audit trails. The parts where a subtle bug is a breach rather than a ticket.
8 projects↗The write path, the ORM, object storage, billing and schema definition. Everywhere state actually comes to rest.
5 projects↗Running Unity and Unreal inside Flutter, with typed messaging both ways and lifecycle handling that survives a backgrounded app.
4 projects↗Hover a module. Distance from the core is how far it sits from the runtime, not how much it matters.
AI agent frameworks treat personality and reasoning style as prompt engineering problems. The agent is a system prompt, a set of tools, and a loop. This paper argues that is a dead end for production systems and presents The Human Model, a compositional architecture that decomposes agents into seven structured primitives drawn from cognitive science and personality psychology: Skills, Traits, Behaviors, Cognitive Styles, Communication Styles, Perception, and Personas. We describe Cortex, an open-source Go implementation with multi-tenancy, execution tracking, and human-in-the-loop checkpoints. A survey of cognitive architectures (SOAR, ACT-R, BDI), personality modeling research, and contemporary LLM frameworks shows that no existing system covers all seven dimensions. The Human Model fills that gap by applying validated psychological constructs as engineering primitives rather than prompt decorations.
CortexAppend-only hash-linked logs and a legal right to erasure are incompatible in their naive forms. Per-subject encryption resolves the conflict, and the resulting guarantee is bounded by key destruction, surviving metadata and hash algorithm lifetime, each of which is stated explicitly.
ChronicleVaultKeysmithPortable object-relational mappers express queries in the intersection of what their backends support, and applications escape that subset at the first real query. Measures the cost of eliminating query-time reflection on a single insert microbenchmark, and argues the module boundary belongs below query construction.
GroveFabriqMarch: a widget that hosts a Unity player inside Flutter, written to solve one product configurator and now past two thousand stars. It went on to carry a large scale augmented reality production for Aardman and a shipped mobile game. September: Ultimate Backend, because I had rebuilt the same multi-tenant scaffolding three times that year and refused to do it a fourth.
Ultimate first, then North a year later. Both were attempts to get framework ergonomics out of Rust, and both ended in the same place: the lifecycle model worked and the type signatures were unreadable to anyone who had not written them. Neither is maintained. Startup as a declared dependency graph came out of North and is load bearing in everything since.
A year on the data layer under industrial twins in energy, oil and gas, and defence. Four systems of record that disagree about what a pump is called, telemetry that arrives hours late in bulk, and connectivity that is genuinely intermittent. Identity, event time and topology turned out to be the whole problem, and none of them are specific to an industry.
Steel in July, Forge a few days later, then Octopus, Authsome, FARP and ForgeUI through the autumn. The premise was to take the twenty-odd things every backend argues about, decide them once, and put the answer in a framework I would use myself. Twenty more modules followed over the next six months, each one a piece I needed and did not want to write twice.
The transactional write path, and the knowledge graph kit on top of it. One command commits state, a versioned event and an outbox row together, and the graph and search projections are rebuildable from that log rather than written to directly. Everything I learned about late telemetry and multi-source identity is in these two.