Monolex Platform
OpenCLIs
A framework where AI CLIs are open to each other, human reads AI natively, and the journey is preserved.
The Problem
You subscribe to Claude Pro, Codex, and Gemini. Three powerful models. Three separate terminals. Three isolated memories.
Claude doesn't know what you did in Codex. Gemini can't see your Claude sessions. Switch models and you start from zero. The models are powerful individually, but they can't work together.
Wrappers like LangChain solve this with APIs — but that means extra cost per token, rate limits, and you lose each CLI's native capabilities (tools, MCP, agents, hooks).
The Insight
AI CLIs run in terminals. Terminals can run other terminals.
If Claude Code runs in a PTY, and that PTY has shell access, then
Claude can type codex "review this" — just like a human would.
No API. No wrapper. Codex runs with its own official model, on the
human's own subscription. Claude gets the response.
This works in every direction. Any CLI can call any other CLI. The only requirement: they share a terminal.
OpenCLIs
OpenCLIs is the name for this architecture:
┌──────────────────────────────────────────────────────────────────┐
│ OpenCLIs │
├──────────────────────────────────────────────────────────────────┤
│ │
│ "Open" = CLIs are open to each other. │
│ Not open source. Not open API. │
│ Open access between CLI tools through shared terminal. │
│ │
│ Three properties: │
│ │
│ 1. Any AI CLI can invoke any other AI CLI │
│ Via shared PTY. No API keys. Official models. │
│ │
│ 2. Human and AI share the same environment │
│ Same shell, same tools, same file system. │
│ What human can do, AI can do. And vice versa. │
│ │
│ 3. Memory crosses model boundaries │
│ Sessions end, but memory stays. │
│ Models change, but context follows. │
│ │
└──────────────────────────────────────────────────────────────────┘
The third property is the deepest. Why memory that persists across sessions and models changes what the whole thing is — not just what it can do — is the argument of Monobrain: The Unnamed Conversation.
What OpenCLIs Is Not
┌──────────────────────────────────────────────────────────────────┐
│ NOT A WRAPPER │
├──────────────────────────────────────────────────────────────────┤
│ │
│ Wrappers call APIs on your behalf. │
│ OpenCLIs lets each CLI call its own model directly. │
│ Kill the wrapper → experience gone. │
│ Kill any part of OpenCLIs → each CLI still works. │
│ │
├──────────────────────────────────────────────────────────────────┤
│ NOT AN API PROXY │
├──────────────────────────────────────────────────────────────────┤
│ │
│ No tokens consumed by the framework. │
│ No additional API keys needed. │
│ No rate limits imposed. │
│ Each CLI uses the human's existing subscription. │
│ │
├──────────────────────────────────────────────────────────────────┤
│ NOT A NEW AI MODEL │
├──────────────────────────────────────────────────────────────────┤
│ │
│ OpenCLIs doesn't compete with Claude, Codex, or Gemini. │
│ It makes them work together. │
│ New model arrives tomorrow? Install the CLI. Done. │
│ │
└──────────────────────────────────────────────────────────────────┘
Philosophy
The Assumption We Rejected
Every multi-model framework starts with the same assumption: AI models are separate entities that need to be connected. LangChain connects them with chains. CrewAI connects them with roles. AutoGen connects them with protocols. The models are islands, and the framework builds bridges.
OpenCLIs starts from the opposite direction. The models are not separate. They already run in the same place — a terminal. The human already has access to all of them — through subscriptions. The work already flows between them — through files, git, shell. There is nothing to connect. There is only separation to stop enforcing.
Existence Before Distinction
When a human works with Claude Code and then switches to Codex, the ontological view says: two separate tools used sequentially. But what actually happened? One continuous working session in which different models contributed at different moments. The distinction between "Claude's work" and "Codex's work" is applied after the fact, not during the flow.
OpenCLIs preserves this reality. The terminal does not care which model is typing. The file system does not care which model edited a file. Git does not care which model committed. The work exists first. The attribution comes after.
This is why the save tracking system records every file change immediately, and only tags which AI session made it as a secondary field. This is why the PTY function that sends keystrokes accepts the same input from human and AI without distinction. This is why the memory layer indexes all model sessions into one database, not four.
The code does not enforce separation because separation is not fundamental to the work.
Motion Before Category
The conventional approach categorizes first: this is a "Claude task," that is a "Codex task," this requires "Gemini's perspective." Categories are assigned before work begins. The framework then routes tasks to the appropriate model.
OpenCLIs does not categorize. The human starts working. If Claude is running, Claude works. If Claude needs a second opinion, it calls Codex — the same way a human would type codex in a terminal. No routing layer. No task classification. No model selection algorithm. Just one continuous motion that happens to pass through different models.
The categories — which model, which session, which agent — are observed and recorded, but never prescribed. They are useful for understanding what happened, not for determining what should happen.
Why This Matters
Frameworks that start with separation must constantly manage it. They need routing logic, model selection, result aggregation, context passing between agents. Every bridge they build is a new point of failure, a new source of latency, a new thing to maintain.
OpenCLIs has none of this infrastructure because it has nothing to bridge. The terminal is already shared. The file system is already shared. The shell is already shared. The memory, once indexed, is already shared. There is no orchestration layer because the terminal itself is the orchestrator.
This is not minimalism for its own sake. It is a consequence of starting from unity rather than separation. When you assume things are already one, you do not need machinery to make them one.
The Terminal as Common Ground
A terminal is the one environment where human and AI already coexist on equal terms. Both type commands. Both read output. Both modify files. Both use the same PATH, the same installed tools, the same shell configuration.
No other interface has this property. GUIs separate human and AI into different roles — the human clicks, the AI generates. Chat interfaces enforce turns — one speaks, the other responds. APIs create a hierarchy — the caller commands, the server obeys.
The terminal is flat. There is no hierarchy between human and AI in a PTY session. This is not a design choice we made. It is a property of terminals that we chose not to destroy.
OpenCLIs is what happens when you take that property seriously and extend it across models: if one terminal session treats human and AI equally, and that session can invoke any CLI, then every model the human has access to becomes part of the same equal, flat, shared working space.
Not Connecting. Revealing.
OpenCLIs does not connect separate things. It reveals that they were never separate to begin with. The models share a terminal. The sessions share a file system. The memories, once read, share a database. The tools give the same results regardless of caller.
The only thing that was separating them was the assumption that they should be separate. Remove the assumption, and the unity is already there.
The same move applies one level up. What this page does for the tools — refusing a separation that was only ever assumed — Monobrain: The Unnamed Conversation does for the human and the AI itself: the conversation was never two minds exchanging messages, and the memory that persists across models is what lets the whole carry one name.
Install
One line. The default installer brings OpenCLIs, its credential vault, and the NIIA chain.
$ curl -fsSL https://openclis.com/install.sh | sh