An enterprise-grade TypeScript agent framework engineered like a deterministic game engine—built on frame-perfect state snapshotting, contiguous slab memory, and biological osmosis self-mutation.
| Core Navigation | Documentation & Wiki | Subsystem Source Code |
|---|---|---|
| 📌 Executive Brief | 📖 Author's Preface | ⚡ Composition Root |
| ⚡ Comparison Matrix | 🎮 Game Engine Paradigm | 🏭 Engine Factory |
| 🏗️ Architecture Tree | 🎓 Academic Whitepaper | ⚙️ Core Abstracts |
| 🧪 Osmosis Methodology | 📦 1-to-1 Package Matrix | 🧠 Agents Tier |
| 🚀 Quick Start Guide | 🧠 Handoff Strategy Guide | 💾 Sessions Tier |
| 📡 Live Activity Streaming | 📋 API Reference Guide | 🖥️ TUI Components |
| 🤝 Contributing Guide | 📖 Game Engine ADR-008 | 📜 Core Contracts |
To my family, whose quiet encouragement and unconditional warmth gave me the space to dream, tinker, and build in the silence of late nights;
To the open-source community and the legendary pioneers of computer graphics who taught us that code can be written with craftsmanship, elegance, and soul;
And to every engineer who has ever looked at a bloated, sluggish system and believed, in their heart, that we could build something far more beautiful.
This work is dedicated to you. May it serve as a humble gift back to the open world that taught me how to create.
Behind every line of code in LUMI-JOY lies a simple, deeply human story: the quiet joy of tinkering, the thrill of chasing elegance, and a lifelong love for software that feels truly alive.
For years, as Large Language Models emerged, we wrapped these magnificent reasoning models inside heavy, tangled layers of enterprise web architecture ("framework soup"). With every layer of microservice RPC complexity, our tools grew slower, state drifted, and the magic of interacting with intelligence was buried under software friction.
Late one night in August 2026, I thought back to the software that first sparked my childhood wonder: the legendary game engines of computing history. Pioneers like John Carmack taught us a sacred discipline—that memory is precious, every single frame matters, and code written with reverence for real-time physics can render entire virtual universes in milliseconds.
By reframing an AI agent runtime as a deterministic game engine kernel (tick()), allocating a contiguous 16MB Zero-GC Contiguous ArrayBuffer Slab like a classic C++ arena allocator, and capturing frame-perfect state snapshots (GameStateSnapshot), LUMI-JOY proved that software friction was an illusion—enforcing sub-millisecond fast-path latency (
— William Andrew Cruz (bozoegg / CardSorting), Primary Author & Inventor
📖 Read the complete Author's Preface & Dedication.
Select your role for tailored navigation and onboarding instructions:
| Stakeholder Role | Primary Focus | Recommended Onboarding Path & Key Resources |
|---|---|---|
| 👔 Executive & VP of Engineering | ROI, Infrastructure Cost, Latency SLAs & Compliance | Read Business & Technical ROI, evaluate Benchmark SLA Matrix, and review Apache 2.0 License & Defensive Patent Pledge. |
| 🏗️ Enterprise Architect & Tech Lead | Monolith Topology, State Memory Substrates & DSL Engine | Inspect 3-Tier Architecture Tree, review Context DSL & Template Engine, and read ADR-083 Context Lifecycle. |
| 🔒 Security & Compliance Officer | Authentication Security, PKCE OAuth & Permission Gates | Audit Live Activity Streaming, check OpenAI Codex PKCE Setup, and review ADR-082 Streaming Policy. |
| 💻 Software Engineer & Developer | Installation, Local Shell Execution & TypeScript SDK | Follow 3-step Quick Start, test Programmatic SDK Usage, and consult the API Reference Guide. |
-
Goal 1: Predictable Infrastructure Costs & High Density: Enforce a deterministic fast-path floor of at least
$1,000$ frames/second without microservice IPC overhead; consult the live baseline for the current host measurement. -
Goal 2: Strict Turn Latency SLAs: Enforce a mean deterministic fast-path latency below
$1.0\text{ ms}$ through automated guardrail testing. - Goal 3: Enterprise Compliance: Deploy under the Apache License 2.0 backed by an explicit Defensive Patent Non-Aggression Pledge.
- Goal 1: Monolithic Simplicity over Monorepo Bloat: Eliminate 18+ uncoordinated micro-packages in favor of a clean 3-tier TypeScript monolith (
agents,sessions,tooling). - Goal 2: Zero-GC Memory Stability: Prevent runtime garbage collection sweeps during live streaming using a contiguous 16MB ArrayBuffer substrate.
- Goal 3: Deterministic Context Envelopes: Replace raw string concatenation with
ContextDslEngineAST parsing andPromptTemplateEngineconditional block rendering.
- Goal 1: PKCE OAuth Security: Secure OpenAI Codex credentials using local PKCE authentication (
localhost:1455) with encrypted disk storage (~/.lumi/config.json). - Goal 2: Redacted Telemetry: Stream progress events (
CodexProgressAdapter) without leaking raw chain-of-thought, tokens, secrets, or file contents. - Goal 3: Command & Permission Sandboxing: Restrict execution via
CommandPermissionControllerand validate all terminal commands before invocation.
-
Goal 1: Instant Local Setup: Get up and running in under 60 seconds with
npm installandnpx tsx src/index.ts --setup. -
Goal 2: Frame-Perfect State Rewind: Perform
$O(1)$ state restoration under the enforced$0.1\text{ ms}$ warmed-p95 guardrail during iterative agent debugging. -
Goal 3: Type-Safe Programmatic SDK: Embed
LumiMonolithseamlessly into node applications with full TypeScript autocompletion and progress callbacks.
Traditional AI agent frameworks (LangChain, AutoGen, CrewAI, and raw provider wrappers) suffer from systemic architectural flaws that limit their enterprise production readiness:
| Architectural Challenge | Traditional Agent Frameworks | AKD-DSO Engine (LUMI-JOY) |
Business & Technical Impact |
|---|---|---|---|
| Framework Overhead | 18+ micro-packages with RPC/IPC queues |
Single 3-tier monolith (agents, sessions, tooling) |
Measured deterministic fast path with |
| Context Safety & DSL | Loose string joins prone to prompt injection | Formal ContextDslEngine AST parsing & SHA-256 digests |
Deterministic context bounds & injection defense |
| Memory & GC Latency | Dynamic heap allocations causing V8 GC sweeps | Contiguous 16MB ArrayBuffer zero-GC substrate | Zero Garbage Collection pauses during live streaming |
| State Rewind & Audit | Slow transcript re-parsing | Warmed-p95 guardrail below |
Traditional AI agent frameworks treat LLM interactions as loose async request/response handlers or stateless REST calls, leading to state drift, non-reproducible execution paths, and V8 Garbage Collection latency spikes.
LUMI-JOY was explicitly engineered like a Deterministic Game Engine kernel. By adapting core principles from high-performance game engine architecture, LUMI-JOY brings frame-perfect isolation, sub-millisecond turn discipline, and zero-GC memory stability to autonomous AI agents.
┌─────────────────────────────────────────────────────────────────────────────┐
│ DETERMINISTIC GAME ENGINE TURN LOOP │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ [ User Input / CLI Trigger ] │
│ │ │
│ ▼ │
│ ┌─────────────────────────┐ │
│ │ Frame Tick (tick()) │ ◄─── Input ───► DSL Context Projection │
│ └───────────┬─────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────┐ │
│ │ Provider Dispatch │ ◄─── Streaming Events & Activity Timeline │
│ └───────────┬─────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────┐ │
│ │ Immutable State Snapshot│ ◄─── GameStateSnapshot (VFS Overlay + Memory) │
│ └───────────┬─────────────┘ │
│ │ │
│ ▼ │
│ [ O(1) Rewind / Subagent ] ◄─── rewindToSnapshot() (< 0.1ms p95) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
| Game Engine Concept | Traditional Agent Frameworks | LUMI-JOY Game Engine Implementation | Technical & Operational Advantage |
|---|---|---|---|
🕹️ Frame Tick (tick())
|
Loose async handlers & event emitters | Deterministic frame step (AbstractAgentEngine.tick()) |
Serializes turn processing in a strict frame cycle (Input -> Context Assembly -> Dispatch -> Mutation -> Telemetry). |
| 💾 Game Save / Frame Snapshot | Serialized text transcript re-parsing | GameStateSnapshot (In-memory frame snapshotting) |
Captures complete engine state (VFS staged overlays, memory store, token budgets, turn index) at frame |
| ⏪ Frame Rewind & Replay | Manual context re-building or restart | rewindToSnapshot()) |
Sub-millisecond ( |
| ⚡ Arena Memory Allocator | Dynamic heap allocation per turn | Contiguous 16MB ArrayBuffer slab (ArenaAllocator) |
Pre-allocated slab eliminates V8 Garbage Collection (GC) latency pauses during live streaming & tick execution. |
| 🌿 Scene & Subagent Branching | Shared mutable global state | Child Session Forking (AgentSwarmDispatcher) |
Subagent tasks spawn isolated child engine instances pre-initialized from parent state snapshots (createSnapshot()). |
📖 For full technical details and architectural specs, read ADR-008: Deterministic Game Engine Architecture and The Osmosis Paradigm Whitepaper.
-
⚡ Enforced Fast-Path Latency: Direct function dispatch eliminates micro-package IPC/RPC queues;
ArchitectureGuardrailGaterequires mean local frame latency below$1.0\text{ ms}$ . -
📈 Enforced Fast-Path Throughput: The same guardrail requires at least
$1,000$ deterministic frames/second and records the host-specific observation in the live baseline. -
🔄
$O(1)$ State Rewind: In-memory snapshot restoration is verified for state correctness and a warmed p95 below$0.1\text{ ms}$ . -
🔒 Enterprise Security & OAuth PKCE: Native PKCE OAuth 2.0 integration with zero-leak credential storage in
~/.lumi/config.jsonand strict permission gates (CommandPermissionController). -
🧠 Formal Context Envelope DSL & Template Engine: Structured
ContextDslEngineAST parsing (LUMI-CONTEXT/1,LUMI-THREAD/1,LUMI-MEMORY/1,LUMI-TOOL-RESULT/1,LUMI-GOAL/1) andPromptTemplateEngine({{#if}}/{{#unless}}) prevent prompt injection and guarantee deterministic context control. - 🛡️ Contiguous Zero-GC Substrate: 16MB pre-allocated ArrayBuffer memory slab eliminates runtime Garbage Collection latency spikes.
The authoritative run was generated on 2026-08-13T05:44:24.943Z using Node.js v23.5.0 on macOS ARM64. It passed:
| Verification lane | Latest result |
|---|---|
| Pass 192 composition manifest | 142/142 components |
| Runtime capability smoke | 9/9 checks |
| Heterogeneous benchmark suite | 5/5 cases |
| Complete Flappy Bird React + TypeScript + Vite case | 8/8 assertions; 12/12 files |
| Architecture and performance guardrails | 6/6 checks |
Performance timings are host-sensitive and must not be copied forward as permanent guarantees. Read the generated machine-readable baseline, benchmark evidence, and architectural audit for the exact current measurements and regeneration timestamp.
Get up and running with LUMI-JOY in seconds:
Ensure you have Node.js 20.19+ (or a compatible newer release) installed:
# Clone the repository
git clone https://github.com/CardSorting/LUMI-JOY.git
cd LUMI-JOY
# Install dependencies
npm install
# Build the project
npm run buildConfigure your LLM providers (OpenAI Codex OAuth, Anthropic, or OpenAI API keys):
# Launch the interactive guided setup wizard
npx tsx src/index.ts --setup
# or run the global binary if linked:
# lumi --setupCodex OAuth: Select OpenAI Codex OAuth to initiate browser sign-in. Paste the callback authorization code if automatic redirect capture is unavailable. Credentials are stored securely in
~/.lumi/config.json.
# Start the interactive terminal shell
npx tsx src/index.ts
# Run a single prompt directly from the CLI
npx tsx src/index.ts "Build a HTML5 Canvas game in src/app.js"import { LumiMonolith } from "lumi-joy";
// Initialize the deterministic monolith engine
const lumi = new LumiMonolith();
// Execute a frame-perfect turn with real-time progress callbacks
const result = await lumi.tick({
prompt: "Analyze repository topology and write unit tests",
onProgress: (event) => {
console.log(`[${event.phase}] ${event.message}`);
},
});
console.log("Agent Response:", result.response);| Command | Action |
|---|---|
npm test |
Run the complete validation suite, including runtime-baseline contracts, documentation freshness/link checks, and architecture guardrails |
npm run build |
Compile TypeScript (tsc) to dist/ |
npm run smoke |
Verify the current Pass 192 composition and critical runtime completion, rewind, safety, and integrity behaviors |
npm run benchmark |
Run the hermetic latency and throughput benchmark suite |
npm run baseline:update |
Run smoke, benchmarks, and guardrails, then atomically regenerate the live baseline reports |
npx tsx src/index.ts --setup |
Run guided provider & model selection wizard |
The current measured baseline is stored in docs/LIVE_BASELINE.json. docs/BENCHMARK_REPORT.md and docs/GRAND_ARCHITECTURAL_AUDIT.md are generated views of that same run; do not hand-edit their measured values.
| Metric / Feature | Legacy Monorepo (pi-main) |
AKD-DSO Engine (LUMI-JOY) |
Underlying Mechanism / Speedup |
|---|---|---|---|
| Architecture | 18+ Micro-packages |
3-Tier Monolith (agents, sessions, tooling) |
Zero Framework Bloat |
| Execution Loop | Loose Async Handlers |
Deterministic Game Loop (tick()) |
Frame-Perfect Isolation |
| Mean Turn Latency | Live guardrail: |
Direct function dispatch replacing IPC/RPC queues; see the generated live baseline for the current measurement. | |
| Execution Throughput | Live guardrail: |
Direct deterministic fast-path measurement, kept separate from heterogeneous benchmark workloads. | |
| State Rewind Latency |
|
Live guardrail: |
Real snapshot mutation/rewind measured across warmed samples rather than a fixed fallback. |
| VFS Perception Speed |
|
Live benchmark case | In-memory contiguous VFS overlay inspection. |
| Memory Allocation | Dynamic Heap GC Sweep | 16MB Zero-GC Slab | Pre-allocated slab eliminates Garbage Collection sweeps. |
| Complete Game Synthesis | Manual multi-file setup | 12-file React + TypeScript + Vite project | Temp-isolated generation, strict compiler diagnostics, executable physics simulation, responsive Canvas UI, controls, and accessibility checks. |
src/
├── core/
│ ├── contracts/ # System Interfaces & GameStateSnapshot
│ ├── abstracts/ # Abstract Base Classes (DIP)
│ └── utilities/ # Shared progress credential sanitizer
│
├── agents/ # Tier 1: Agents Subsystem
│ ├── base/ # Agent Base Config
│ └── extensions/ # Domain Mutation Subdirectories
│ ├── compaction/ # prompt-composer.ts
│ ├── resolution/ # model-resolver.ts, agent-slash-router.ts, model-catalog.ts
│ ├── execution/ # agent-engine.ts, Codex progress adapter, interactive controller
│ ├── mentions/ # mention-resolver.ts (Pass 9)
│ ├── swarm/ # agent-swarm-dispatcher.ts (Pass 11)
│ └── intelligence/ # workspace-intelligence.ts (Pass 13)
│
├── sessions/ # Tier 2: Sessions Subsystem
│ ├── base/ # Session Context Base
│ └── extensions/ # Domain Mutation Subdirectories
│ ├── substrate/ # arena-allocator.ts, file-lock.ts (Pass 20)
│ ├── persistence/ # session-store.ts
│ ├── memory/ # session-memory-store.ts
│ ├── vfs/ # session-vfs.ts
│ ├── compaction/ # session-compactor.ts, snapcompact-engine.ts (Pass 15)
│ └──> 🛡️ **Non-Destructive Osmosis Extension Strategy (`ADR-012`)**:
> Base classes in `src/*/base/` remain immutable. Evolutionary passes introduce single-responsibility extension classes in dedicated mutation subdirectories (`src/*/extensions/<mutation-domain>/`) and compose them cleanly in `MonolithFactory` and `LumiMonolith`.
---
## 📡 Live Agent Activity Streaming
Authenticated Codex turns use the official SDK event stream and render a persistent activity card instead of a single ambiguous `Thinking...` label. Stable activities update in place as they move through `started`, `in_progress`, and a terminal state.
Use `/setup` to connect and activate a provider. Codex setup attempts to open the browser, but also displays a clickable and copyable OpenAI sign-in URL; press `O` to retry or paste the authorization code/full callback URL if automatic redirect capture is unavailable. When Codex is already authenticated, submit an empty field to keep the login and activate its default model. The selection is saved in `~/.lumi/config.json`.
```text
Agent activity · Working 4s · gpt-5.6-terra
✓ Connected to Codex — gpt-5.6-terra
◐ Analyzing the request — Understanding goals and workspace context
◐ Running workspace command — npm test
The timeline can show safe reasoning summaries, plan progress, redacted commands, relative file changes, MCP/web activity, response-candidate state, elapsed time, and final token totals. A completed message item is only a candidate: LUMI reports success after the provider turn also terminates and the candidate passes final-response validation. It never displays raw chain-of-thought, aggregated tool output, MCP payloads, OAuth material, or full response text.
Press Esc or Ctrl+C to cancel an active turn. Cancellation and failure settle active child rows, discard the failed Codex thread, restore the loop phase to idle, and leave the terminal audit trail visible.
Programmatic callers can consume the same lifecycle through EngineTickInput.onProgress:
const abortController = new AbortController();
const result = await lumi.tick({
prompt: "make a racing game",
signal: abortController.signal,
onProgress: (event) => {
console.log(event.activityId, event.status, event.message, event.detail);
},
});
if (result.outcome !== "completed") {
// `response` contains safe failure or cancellation guidance, not a successful answer.
console.error(result.response);
}See the complete streaming strategy, public API reference, and ADR-082.
LUMI separates the full conversation transcript from the bounded context projection sent to a model. The transcript remains available for persistence, snapshots, forks, rewind, and SHA-256-addressed recall; the active projection keeps pinned system policy, one structured checkpoint, and the newest complete user turns.
Context admission is model-aware and token-aware:
model context window
├── reserved model output
├── safety margin
└── usable model input
├── pinned system + memory context
└── active conversation projection
├── LUMI-CONTEXT/1 checkpoint
└── recent complete turns
Compaction triggers before the hard provider limit and targets a lower utilization level, leaving space for subsequent tool rounds. A final turn-aware guard prevents provider-side blind truncation. All context envelopes (LUMI-CONTEXT/1, LUMI-THREAD/1, LUMI-MEMORY/1, LUMI-TOOL-RESULT/1, LUMI-GOAL/1) are parsed, validated, and serialized through ContextDslEngine. System prompts are compiled via PromptTemplateEngine, supporting handlebar variable placeholders ({{var}}) and conditional blocks ({{#if}}/{{#unless}}). Stateful Codex threads are automatically rehydrated from LUMI-THREAD/1 after compaction, rewind, model changes, stateless provider turns, or local-only responses.
Run npm test to exercise DSL AST parsing (scripts/validate-dsl-strategy.ts), message pressure, token pressure, oversized DSL/code input, checkpoint recurrence, durable persistence, rewind, and multi-turn thread handoff. See ADR-083 for the policy and trade-offs.
LUMI implements a zenith-tier Attempt Completion Gate Strategy (RoadmapCompletionGate and AttemptCompletionGateStrategy) to enable autonomous multi-attempt turn progression without manual user prompting or feedback:
-
Phased Gating Lifecycle: Evaluates quality bars across
admission,in_flight,completion, andpostmortemcheckpoints. - Dynamic Context Evaluators: Analyzes candidate outputs, tool execution outcomes, and runtime error diagnostics.
-
Differential Attempt Analysis (
computeAttemptDiff): Tracks delta improvements and catches regressions (newlyPassing,newlyFailing,stagnantFailing) across attempts. -
Cognitive Remediation Directives (
RemediationDirective): Automatically synthesizes root causes, prioritized criteria, and concrete action steps, escalating strategies (PATCH_LOCAL$\to$ REWRITE_MODULE$\to$ PIVOT_APPROACH$\to$ EXPAND_CONTEXT) when localized patches fail. -
Anti-Oscillation Guard & Circuit Breaker: Detects cyclic repair traps (
[ANTI_OSCILLATION_GUARD]) and trips circuit breakers (CircuitBreakerConfig) to prevent infinite retry loops and runaway token burn.
See ADR-084 for architectural specifications and benchmarks.
To prevent code regression, file overwrites, and structural drift as new evolutionary passes are absorbed from pi-main, LUMI-JOY strictly enforces the Non-Destructive Extension & Mutation Directory Strategy:
- Base Class Immutability: Base domain classes in
src/*/base/(e.g.Eyes,SessionContext,AgentConfig) are foundational and immutable. - Single-Responsibility Mutation Subdirectories: Every evolutionary pass or feature mutation creates a dedicated, single-responsibility file in a domain-scoped subdirectory inside
src/*/extensions/<mutation-domain>/. - Zero-Barrel Import Policy: All intermediate
index.tsbarrel re-export files are prohibited. Imports across subsystems MUST target explicit, deep relative paths. - Dependency Inversion Monolith Composition: Extension classes extend base abstractions and are composed at the composition root (
MonolithFactory&LumiMonolith).
| Subsystem Tier | Mutation Directory | Pass / Feature Responsibility | Extension Class |
|---|---|---|---|
Agents (src/agents/extensions/) |
compaction/ |
System prompt compilation & context assembly | PromptComposer |
resolution/ |
Model fallback resolution, slash routing & pricing specs | ModelResolver, AgentSlashRouter, ModelCatalog |
|
execution/ |
Deterministic tick execution, Codex lifecycle adaptation, interactive orchestration | AgentEngine, CodexProgressAdapter, InteractiveModeController |
|
mentions/ (Pass 9) |
Prompt @mention context expansion |
MentionResolver |
|
swarm/ (Pass 11) |
Subagent task delegation & frame snapshot sync | AgentSwarmDispatcher |
|
intelligence/ (Pass 13) |
Workspace topology & package identity indexing | WorkspaceIntelligenceEngine |
|
Sessions (src/sessions/extensions/) |
substrate/ |
Contiguous 16MB ArrayBuffer slab allocation & file locks | ArenaAllocator, FileLockManager, LruCache |
persistence/ |
File persistence & frame-perfect snapshot rewind | PersistentSessionStore |
|
memory/ |
Long-term fact store & KI persistence | SessionMemoryStore |
|
vfs/ |
In-memory Virtual File System diff overlay | SessionVfs |
|
compaction/ |
Sliding window compaction & dense bitmap archiving | SessionCompactor, SnapcompactEngine |
|
integrity/ (Pass 12) |
Environment auditing & forensic self-healing | StabilityDoctor |
|
Tooling (src/tooling/extensions/) |
perception/ |
AST structural code symbol search | AstPerceptionEyes |
progress/ |
Legacy JSON-RPC progress notification formatting; distinct from provider activity | ProgressStreamingEars, TerminalProgressRenderer |
|
telemetry/ |
Microsecond performance timers & OpenTelemetry spans | ProtocolEars, TelemetryTracer |
|
hashline/ |
Line-anchored hash edit verification | AnchoredHands |
|
registry/ |
Skill discovery & schema validation tool execution | SkillsIngestor, ValidatingToolRegistry |
|
policy/ (Pass 10) |
Zombie symbol detection & dependency analysis | ModuleDecomposer |
|
permissions/ (Pass 14) |
Command permission controller & execution guardrails | CommandPermissionController |
|
gateway/ (Pass 17) |
JSON-RPC 2.0 streaming gateway server | MonolithGatewayServer |
LUMI-JOY is an enterprise-grade AI pair programmer and autonomous agent engine. It addresses framework overhead and state drift through a deterministic local frame path guarded below
Traditional AI agent frameworks suffer from state drift, non-reproducible turns, microservice overhead, and V8 Garbage Collection pauses. Modeling the agent runtime like a Deterministic Game Engine establishes frame ticks (tick()), immutable state snapshots (GameStateSnapshot), sub-millisecond state rewind (rewindToSnapshot()), and a pre-allocated 16MB contiguous slab memory substrate (ArenaAllocator). This guarantees frame-perfect isolation, instant time-travel debugging, and zero-GC performance stability.
By eliminating internal microservice RPC queues, LUMI-JOY keeps deterministic local orchestration in-process. The enforced floor is
LUMI-JOY natively supports major provider ecosystems including OpenAI (gpt-4o, gpt-5, Codex), Anthropic (Claude 3.5 Sonnet), and standard OpenAI-compatible proxy gateways. It features automatic model resolution, fallback routing, and PKCE OAuth 2.0 authentication.
LUMI-JOY runs locally or within your private cloud infrastructure. Credentials configured via /setup are stored in restricted user storage (~/.lumi/config.json with 0600 permissions). The engine explicitly redacts credentials, bearer tokens, and internal file contents from streaming activity logs, and enforces strict command permission policies before executing any terminal operations.
Yes. LUMI-JOY is open-source under the Apache License 2.0 and backed by a Defensive Patent Non-Aggression Pledge. You can integrate the TypeScript SDK (LumiMonolith) directly into internal developer portals, custom CLI tools, IDE plugins, or automated CI/CD code repair pipelines.
Developers receive real-time, transparent feedback through a differential terminal timeline UI or progress event stream. Instead of displaying a static "Thinking..." label, LUMI-JOY shows live activity updates (file viewing, test execution, plan updates) with elapsed time timers and clear completion status.
Engineering teams can install LUMI-JOY in under 60 seconds with npm install and complete provider authentication using the built-in guided wizard (lumi --setup). Programmatic integration requires only 4 lines of TypeScript code.
- 🚀 Auto-Rolling Evolution Roadmap
- 📋 Workspace Changelog
- 🎓 Academic Research Paper: AKD-DSO Specification
- 📦 True 1-to-1 Package Mapping Matrix
- 📄 Whitepaper: The Osmosis Paradigm
- 🧠 The Osmosis Methodology & Handoff Guide
- 📖 Wiki Landing Page
- 📋 API Reference Guide
- 📡 Agent Activity Streaming Strategy
- 🧭 ADR-082: Structured Agent Activity Streaming
- 📈 Current Machine-Readable Baseline
- 🧪 Generated Benchmark Evidence
- 🏛️ Generated Architectural Audit
- 📖 ADR Index & Decision Records
- 🤝 Contributor Guidelines
- 📄 Distributed under the Apache License 2.0. See LICENSE and NOTICE for details.