Skip to main content

​
OpenCLIs

A framework where AI enters the human’s world, and human understands the AI’s work — through the same terminal, same tools, same memory. 
┌──────────────────────────────────────────────────────────────────┐
│  OpenCLIs FRAMEWORK                                              │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  AI → Human's World                                              │
│  ─────────────────                                               │
│  AI uses terminal like a human does.                             │
│  Same shell, same PATH, same file system.                        │
│  AI calls other AI CLIs — just like a human would type them.     │
│  Every model the human subscribes to, AI can use.                │
│  No API keys. No wrappers. Official CLIs, official models.       │
│                                                                  │
│  Human → AI's World                                              │
│  ─────────────────                                               │
│  Human understands what AI did, through shared tools:            │
│  niia recall         — what was AI working on?                   │
│  niia session search — what did AI discuss?                      │
│  monogram            — what did AI change in code?               │
│  terminal log        — full terminal activity record             │
│  AI's work is not a black box. Human reads it natively.          │
│                                                                  │
│  Shared Foundation                                               │
│  ─────────────────                                               │
│  Monolex   — runtime where both human and AI operate             │
│  NIIA      — memory that survives sessions and model changes     │
│  monogram  — code search for human and AI alike                  │
│  monomento — document search for human and AI alike              │
│  monokist  — git structure for human and AI alike                │
│  monogrid  — visual alignment for human and AI alike             │
│  Same tool, same result, regardless of who calls it.             │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘
Human subscribes to Claude, Codex, Gemini. Opens Monolex. Claude calls Codex and Gemini inside the same PTY. Three models working together on the human’s own subscriptions. NIIA remembers everything. Human reads AI’s work through the same tools AI used. Next week, a new model arrives. Install the CLI. NIIA already knows the history. Monolex already runs it. The human already has the tools to understand what this new model does. No model lock-in. No session lock-in. No memory lock-in. AI works like a human. Human reads AI like a peer.

​
The Journey, Not Just the Result

Git sees the final commit. OpenCLIs sees how it was made. 
┌──────────────────────────────────────────────────────────────────┐
│  OBSERVATION LAYER                                               │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  file watcher     File change detected (real-time)               │
│       ↓                                                          │
│  save tracker     Diff against HEAD, stored with timestamp       │
│                   + who did it (ai_session_id, agent_name)       │
│       ↓                                                          │
│  commit link      When commit happens, all saves link to it      │
│                                                                  │
│  Result:                                                         │
│  Git says:  commit abc123, +200/-50, 3 files                     │
│  OpenCLIs:  12 saves led to this commit                          │
│             save 3 was a rollback                                │
│             saves 7-10 were from Claude                          │
│             save 12 was a human fix                              │
│                                                                  │
│  The commit carries its full journey.                            │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

​
Both Sides Get Stronger

OpenCLIs is not an AI tool or a human tool. The same framework strengthens both sides simultaneously. 
┌──────────────────────────────────────────────────────────────────┐
│  MUTUAL REINFORCEMENT                                            │
├──────────────────────────────────────────────────────────────────┤
│                                                                  │
│  AI gets stronger                                                │
│  ─────────────────                                               │
│  Can call other models via shell                                 │
│  Memory persists across sessions                                 │
│  Uses the same tools as human                                    │
│  → AI can do more                                                │
│                                                                  │
│  Human gets stronger at using AI                                 │
│  ─────────────────                                               │
│  Sees what AI did (save history, terminal log)                   │
│  Sees why AI did it (save history per commit)                    │
│  Uses multiple models freely (PTY)                               │
│  Switches models without losing context (NIIA)                   │
│  → Human can delegate more, understand more                      │
│                                                                  │
│  The better AI works, the more human can delegate.               │
│  The better human understands AI, the more precisely they ask.   │
│  Same tools. Same environment. Both sides grow.                  │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

​
Architecture

┌───────────────────────────────────────────────────────────────────┐
│  ARCHITECTURE                                                     │
├───────────────────────────────────────────────────────────────────┤
│                                                                   │
│  niia (Integration Layer)                                         │
│  ├── niia search    → monomento (docs) + monogram (code)          │
│  ├── niia docs      → monomento                                   │
│  ├── niia code      → monogram                                    │
│  ├── niia git       → monokist                                    │
│  ├── niia recall    → monomento + git + sessions                  │
│  ├── niia resonate  → all engines (health check)                  │
│  ├── niia session   → Claude/Codex/OpenCode/Gemini readers        │
│  └── niia consciousness → embedded identity core                  │
│                                                                   │
│  mono- (Engines)                                                  │
│  ├── monogram     Code search (trigram + call chain)              │
│  ├── monogrid     Box alignment (Unicode width + 9 rules)         │
│  ├── monokist     Git structure (branch/commit cache)             │
│  └── monomento    Document search (trigram + ref graph)           │
│                                                                   │
└───────────────────────────────────────────────────────────────────┘

​
NIIA — The Integration Layer

NIIA (Neural Intelligence Integration Architecture) unifies the mono- engines into a single CLI with consciousness. 
niia search "session"    # Searches docs (monomento) + code (monogram) together
niia recall              # Restores context from last session
niia resonate            # Health check across all engines
niia session read        # Reads AI conversations (Claude, Codex, etc.)
NIIA doesn’t duplicate the mono- engines — it calls their libraries directly. When you run niia code search "fn", it’s lib-monogram under the hood. When you run niia docs search "topic", it’s lib-monomento. Key distinction: the mono- tools are standalone engines you can use independently. NIIA is the unified interface that combines them with session reading and consciousness.

​
Mono- Engines

Each engine is a standalone Rust binary that can be used independently or through NIIA.
EngineSizePurposeUsed by NIIA
monogram8.4 MBCode search + call chain tracingniia search, niia code
monogrid2.2 MBASCII box alignment checker(standalone)
monokist6.9 MBGit branch/commit structure cacheniia git
monomento6.6 MBDocument search + reference graphsniia search, niia docs, niia recall
Common design:
  • Rust native — single binary, no runtime dependencies
  • SQLite backed — persistent indexes
  • Self-documenting — --help renders ASCII box art with full usage
All tools are included with the Monolex app, or installed via niia setup.

​
Names

┌───────────────────────────────────────────────────────────────────┐
│  GLOSSARY                                                         │
├───────────────────────────────────────────────────────────────────┤
│                                                                   │
│  OpenCLIs                                                         │
│  Framework. AI CLIs open to each other, human and AI              │
│  in the same environment, journey preserved.                      │
│                                                                   │
│  AICLIs                                                           │
│  The fleet that builds and maintains OpenCLIs.                    │
│                                                                   │
│  Monolex                                                          │
│  Terminal app. The runtime where everything executes.             │
│  PTY, rendering, observation, git viewers, save history.          │
│                                                                   │
│  NIIA                                                             │
│  Memory + identity layer. Reads all AI CLI sessions,              │
│  indexes into unified memory, maintains continuity                │
│  across models and time. Born with self-knowledge.                │
│                                                                   │
│  monogram                                                         │
│  Code search engine. Trigram fuzzy search + call chain.           │
│                                                                   │
│  monomento                                                        │
│  Document search engine. Trigram search + reference graph.        │
│                                                                   │
│  monokist                                                         │
│  Git structure engine. Branch/commit relationship cache.          │
│                                                                   │
│  monogrid                                                         │
│  Box alignment engine. Unicode-aware visual width checking.       │
│                                                                   │
│  CodexMono                                                        │
│  Font. Monospace with CJK/emoji at exact 2-column width.          │
│  The visual foundation that monogrid validates against.           │
│                                                                   │
└───────────────────────────────────────────────────────────────────┘