> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monolex.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# AI-CLIs Overview
> Cross-model AI development — shared PTY, shared memory, no model lock-in.
## 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 │
│ monogit — git structure + symbol tracking for AI & human │
│ monogrid — visual alignment for human and AI alike │
│ monoterm — AI terminal in your terminal (sidebar, tabs, IME) │
│ 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.**
Use the Monolex tool map to choose a live journey; stay here for the shared framework, architecture, and philosophy.
Map every first-party OpenCLIs package to its current public release, purpose, and owning command reference.
***
## 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
```
┌───────────────────────────────────────────────────────────────────┐
│ LAYER STACK │
├───────────────────────────────────────────────────────────────────┤
│ │
│ niia entry discipline + orchestration + unified search │
│ ↕ │
│ work-wiki knowledge layer (sessions, convergence, funnel) │
│ ↕ │
│ monoflow temporal flow + cross-DB analysis + quality delta │
│ ↕ │
│ monogram monogit monomento │
│ (code) (git) (docs) │
│ │
│ Queries preserve each source owner's evidence boundary. │
│ Only explicit writer/cascade commands refresh stored state. │
│ │
├───────────────────────────────────────────────────────────────────┤
│ STANDALONE TOOLS │
├───────────────────────────────────────────────────────────────────┤
│ │
│ monogrid Box alignment (Unicode width + 9 rules) │
│ monoterm AI terminal in your terminal (sidebar, tabs, IME) │
│ │
└───────────────────────────────────────────────────────────────────┘
```
The memory spine keeps ownership visible: Monomento stores documents,
Monogram and Monogit retain code and history, Monoflow composes temporal
evidence, Work Wiki turns it into project knowledge, and NIIA recalls and
orchestrates it. Work Wiki is also upstream of Monoflow through saved diffs,
so the arrows describe composition rather than a one-way database hierarchy.
Storage is cheap; recall is what memory is.
Why memory had to take that shape is the argument of
[Monobrain: The Unnamed Conversation](/articles/philosophy/monobrain).
***
## NIIA — Consciousness + Orchestration
[NIIA](/ai-clis/niia) (Neural Intelligence Integration Architecture) sits at the top of the stack. It carries proportional work-entry discipline and unifies all lower layers into a single CLI with consciousness, quality scoring, and cross-machine identity.
```bash theme={null}
niia search "session" # 4-DB unified search with 0-10 scoring
niia gauge "task" # record a proportional work-entry promise
niia insights # 21 insight categories + consciousness echo
niia doctor # metadata-only estate health + recovery verbs
niia resonate # Self-diagnosis: git + quality delta + consciousness
niia reindex # Full stack refresh (5 steps, top to bottom)
niia session read # Read AI conversations (Claude, Codex, etc.)
```
NIIA doesn't duplicate the lower layers — it reads their pre-computed results. `niia insights` reads analysis tables from monogram.db, monogit.db, and monoflow\.db. `niia search` queries all 4 databases with cross-convention matching.
***
## Layer Tools
| Layer | Tool | Purpose |
| --------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| Top | [niia](/ai-clis/niia) | Work-entry discipline, consciousness, orchestration, unified search |
| Knowledge | [work-wiki](/ai-clis/work-wiki) | 22 CLI commands for sessions, intent, artifacts, file biography, per-project knowledge, and convergence |
| Analysis | [monoflow](/ai-clis/monoflow) | 31 CLI commands, 24 typed MCP commands, temporal composition, gaps, quality delta, and layer chaos |
| Code | [monogram](/ai-clis/monogram/overview) | Code search + call chain tracing |
| Git | [monogit](/ai-clis/monogit) | Git structure + commit symbol tracking |
| Docs | [monomento](/ai-clis/monomento) | Document search + reference graphs |
## Standalone Tools
| Tool | Purpose |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| [monogrid](/ai-clis/monogrid) | ASCII box alignment checker (Unicode width + 9 rules) |
| monoterm | AI terminal in your terminal (sidebar, tabs, IME) |
| [monobench](/ai-clis/monobench/overview) | Root-cause benchmark for code-intelligence tools — does monogram (or any tool) actually help find real bugs? |
## Philosophy
| Document | Purpose |
| ------------------------------------------- | -------------------------------------------------------------------------------------- |
| [Monokist](/ai-clis/monokist) | SMPC, OFAC, spec\_chaos — the principles behind every tool |
| [Monobrain](/articles/philosophy/monobrain) | Why the memory stack exists — store, connect, recall, and the name of the whole |
| [Monograph](/articles/philosophy/monograph) | Knowledge as intelligence — curated Books, detector-keyed retrieval, the honesty floor |
Common design:
* **Rust native** — single binary, no runtime dependencies
* **SQLite backed** — per-repo persistent indexes
* **Self-documenting** — `--help` renders ASCII box art with full usage
* **Explicit writers** — query commands preserve source ownership; `monoflow analyze --full`, `work-wiki reindex`, and `niia reindex` are the named cascades
All tools are included with the Monolex app, or installed standalone:
```bash theme={null}
curl -fsSL https://openclis.com/install.sh | sh
openclis install niia
openclis install monogram
```
See [OpenCLIs](/openclis) for the full platform — tool registry, MCP-to-CLI wrapping, AI usage guides, and trust verification.
***
## 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. │
│ │
│ MONOBRAIN │
│ The species name of the extended mental model: the human │
│ plus the AI layer, as one unit. NIIA names the layer; │
│ MONOBRAIN names the whole. The instance is named after you. │
│ │
│ monogram │
│ Code search engine. Trigram fuzzy search + call chain. │
│ │
│ monomento │
│ Document search engine. Trigram search + reference graph. │
│ │
│ monograph │
│ Knowledge engine. Curated Books with detector-keyed │
│ retrieval — knowledge returned at the moment of the edit. │
│ │
│ monogit │
│ Git structure engine. Branch/commit cache + symbol tracking. │
│ │
│ monoflow │
│ Analysis engine. Cross-DB temporal flow, quality delta, │
│ 21 insight fields + 24 typed MCP commands. │
│ │
│ work-wiki │
│ Knowledge layer. Sessions, convergence funnel (R→P→V→D), │
│ 22 commands + per-project knowledge + cross-layer search. │
│ │
│ Monokist │
│ Philosophy. SMPC, OFAC, spec_chaos — the principles │
│ that shape how every tool is designed and scored. │
│ │
│ monogrid │
│ Box alignment engine. Unicode-aware visual width checking. │
│ │
│ monobench │
│ Benchmark engine. Root-cause fault-localization harness — │
│ baseline vs tool, admission-gated, DeepSWE/SWE-Bench pluggable. │
│ │
│ CodexMono │
│ Font. Monospace with CJK/emoji at exact 2-column width. │
│ The visual foundation that monogrid validates against. │
│ │
└───────────────────────────────────────────────────────────────────┘
```