Modern developers often find themselves trapped in a cycle of fragmented intelligence. You might start a complex refactor with Claude Code, only to hit a logic wall that requires the specific reasoning strengths of Gemini or the specialized skills of Codex. The transition is rarely seamless. Instead, the developer becomes a human clipboard, manually summarizing previous attempts, copying error logs, and explaining the current state of the codebase to the new model. This manual handoff is where critical context leaks, leading to repetitive mistakes and a degradation of the development velocity.

The Infrastructure of Shared State

Framein v0.0.6 emerges as a solution to this fragmentation by implementing a local layer that allows disparate AI coding agents to share a unified work-state. Unlike traditional cockpit or proxy architectures that require replacing the IDE or the agent harness, Framein operates as a thin state layer residing beneath the agents already in use. This design ensures that the developer does not have to abandon their preferred toolchain to gain the benefits of state synchronization.

To get started, the environment requires Node 22.5 or higher. The tool is distributed via npm and can be installed globally using the following command:

npm install -g framein

Released under the MIT license, the current build has already passed 249 tests, ensuring the stability of its core components. These components include a centralized store, a system for work contracts, validation and risk gates, and a Model Context Protocol (MCP) server. The tool is designed to be agnostic regarding the agent's interface. While it supports direct terminal calls, it provides specialized commands for popular agents to streamline the workflow. For those using Claude and Gemini, the system integrates via `/fr:*` slash commands, while Codex users can trigger the layer using `$fr-*` skills. This allows a developer to pivot between different models while maintaining access to the same local engine and state data.

Beyond the Human Clipboard

The fundamental shift Framein introduces is the replacement of the summary-based handoff with a factual ledger. In a typical multi-model workflow, one model passes a summary of its work to the next. This is inherently lossy. Framein instead utilizes a work contract and a ledger, forcing every model to read from the same source of truth within the repository. This process is governed by a four-stage loop that transforms how AI agents collaborate.

Everything begins with the start phase. Rather than a vague prompt, the request is codified into a work contract. This contract explicitly defines the goal, acceptance criteria, protected areas of the code that must not be touched, and non-goals to prevent scope creep. Once the contract is set, the process moves to the challenge phase. To combat the common problem of model overconfidence, Framein allows models other than the current lead to provide narrow-scope counterarguments to the proposed implementation. The lead model responds once, and the human developer makes the final decision, ensuring a system of checks and balances.

Following this, the capsule phase prepares the transition. Instead of a chat history, Framein packages the contract, the diff, validation results, Architecture Decision Records (ADRs), and the ledger for the next lead model to ingest. The cycle concludes with the ship phase. Here, the definition of completion is stripped of subjective AI judgment. A task is only considered finished when it passes actual builds, tests, and predefined risk gates.

This architecture is built on a foundation of strict data integrity. ADRs are recorded in an append-only format, meaning decisions cannot be edited or deleted. This ensures that any subsequent model can trust the history of the project without fearing that the context has been rewritten. For storage, Framein leverages the built-in `node:sqlite` available in Node 22 as a cache, while the primary data is stored as git-friendly JSON snapshots. By designing the system with zero runtime dependencies, the developers have eliminated the risk of installation failures caused by external library updates. Furthermore, Framein avoids the security pitfalls of proxy tools; it does not scrape terminal I/O or relay tokens, leaving authentication entirely to the official CLIs.

By removing the need for context re-explanation, Framein shifts the developer's role from a data mediator to a high-level orchestrator. It does not aim to make a single agent smarter, but rather to stop the leakage of state that occurs when a project moves across different intelligences. For developers who utilize multiple models for cross-verification, this provides a way to maintain distinct model personas while anchoring them to a common, immutable ledger of facts.

Detailed technical documentation and the source code are available on the official GitHub repository at [https://github.com/framein-dev/framein].

Framein transforms the AI coding experience from a series of disconnected sessions into a continuous, verifiable pipeline.