The runtime for AI coding agents.

Orqenix runtime.

Orqenix is a local runtime for AI coding agents. It runs on localhost:27420 and exposes a set of independent subsystems your agent connects to over MCP. Memory, plugins, skills, orchestration, self-learning, and a control plane, all in one process, all on your machine.

It does not replace your agent and it does not sit between your agent and the model. Your agent connects to Orqenix the same way it connects to any tool, then calls its model directly. You bring the agent. You bring the model. Orqenix is the platform underneath.

How memory is organized.

Memory is one of the six subsystems, and the one most teams notice first. Orqenix mirrors how developers actually work, with five nested scopes that match your git workflow. Each scope owns its own memory, and memory flows downward through copy-on-write.

org/acme                          # your organization
└── user/milo                    # a developer (you)
    └── project/auth-service     # a git repo
        ├── branch/main          # production branch
        │   ├── session/s-4f2a   # this morning's IDE session
        │   ├── session/s-9c1b   # yesterday's debug session
        │   └── session/s-2e3d   # last week's refactor
        └── branch/jwt-rotation  # feature branch
            ├── session/s-c41d   # design decisions
            └── session/s-b6f8   # implementation

# Each scope holds its own 4x4 memory matrix.
# Branches copy-on-write from project. Sessions
# live on top of branches. Capability tokens
# control who can read what, and how far.

Why memory routes, not replicates.

Cloud memory tools default to replication: shove everything into one shared store and let access control sort it out. That breaks on privacy, latency, and trust. Orqenix routes instead: memory stays in its scope of origin, and capability tokens authorize cross-scope reads on demand, narrowing at every hop.

Why a matrix, and not a vector blob.

Most memory tools embed everything as opaque vectors and let the LLM "figure it out." That breaks the moment you need to know which memory came from where, why it was retrieved, and what its trust level is. Orqenix takes the opposite bet: structured first, embedded second. A 4×4 matrix of memory tiers crossed with knowledge bases gives every memory a precise coordinate.

Same agent. Same model. Better answers.

Memory, plugins, and skills exist to do one thing: build a better prompt before it reaches the model. Alignment is the goal, not memory itself.

When your agent asks the model a question, the answer is only as good as the context inside that prompt. Generic context produces generic answers. Wrong context causes goal drift, where the model confidently goes off in a direction your codebase never agreed to. Missing context forces the model to guess, and guesses become bugs.

The Workbench is where you watch the runtime assemble that context. A deterministic pipeline (recall, distill, sign, rerank, inject, send) builds the prompt from the specific past decisions, code patterns, and session history that relate to the request. You can audit every step. If the model gives a bad answer, you can see exactly which memory caused it.

Your runtime gets smarter with use.

Most tools stay frozen at install time. Orqenix watches what your agent actually does, finds patterns that repeat, verifies them against history, and promotes them into reusable skills. The runtime you use next week is not the one you installed yesterday.

It is not magic. It is a four-stage loop, fully inspectable, fully auditable. Nothing graduates to a skill without passing verification, and the human stays in control of every promotion.

Extend it. Orchestrate it. Enforce it.

Memory is one subsystem. The platform is everything else that makes the agent run well. Plugins, skills, harness, and methodology enforcement — composable building blocks, not fixed features.

A marketplace, not a feature list.

Skills, plugins, MCP servers, hooks — published by the community, signed at publish, installed locally. The runtime stays small. The ecosystem grows. What you can do with Orqenix tomorrow is more than what shipped today.

Built for capabilities no other tool ships.

Most memory tools solve a slice of the problem. Orqenix is a full runtime: nested git-aware scopes, cryptographic provenance, capability-controlled routing, a self-learning loop, a plugin marketplace, and Apache 2.0, all in one process.

Memories you can cryptographically trust.

Every memory is signed at the moment it is written. Every cross-scope read is verified against the signature chain. Every audit trail is hash-linked. You can prove, end to end, exactly where any piece of context in your LLM prompt came from.

Built in the open. Forever.

Shipped today. Shipping tomorrow.

Orqenix is built incrementally. Each phase is a complete, usable system on its own, never a half-finished feature waiting for the next release.