Skip to main content

​
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.