AHP+: An Open-Source Protocol Solving Context Loss When Switching Between AI Coding Tools

When collaborating across multiple AI coding tools, developers frequently face a frustrating problem: every time they switch tools or chat sessions, the project's context information is lost. To address this pain point, developer Jossue Alcala created the open-source project AHP+, which persistently stores project state through a Git-backed protocol.

The Context Fragmentation Problem in Multi-Tool Collaboration

In modern AI-assisted programming, developers often need to switch between multiple tools like Claude, Codex, and Cursor, or even migrate across different IDEs and devices. The cost of this flexibility is context fragmentation — when you start a new conversation or switch tools, previously discussed architectural decisions, key assumptions, and project progress vanish along with the chat history.

To understand the root cause, you need to know how current AI coding tools work under the hood. Large language models like Claude and GPT rely on a finite "Context Window" for each interaction — the maximum number of tokens the model can process in a single inference. Although the latest models have expanded context windows to 100K or even 1M tokens, once a chat session is closed or you switch tools, the project understanding accumulated during the conversation doesn't automatically transfer. More fundamentally, each AI tool maintains its own independent conversation history and memory mechanism — the project understanding maintained by Cursor's Composer mode can't be passed to Claude Code, and vice versa. This "memory silo" phenomenon is exactly the core pain point AHP+ aims to solve.

This not only leads to repetitive work but can also cause newly introduced AI tools to make incorrect judgments based on outdated or incomplete information. For projects requiring long-term maintenance or multi-person collaboration, this context loss is particularly devastating.

AHP+'s Core Design Philosophy: Separated Storage with Version Control

AHP+ (AI Handoff Protocol Plus) adopts a "separated storage" design philosophy: it extracts critical project state information from temporary chat sessions and manages it through Git repositories with version control. Its core idea can be summed up as: Change the AI. Keep the project.

Choosing Git as the underlying storage mechanism is no accident. Git is the most widely used distributed version control system in software development, and virtually all development projects already use Git for code management. By incorporating project state files directly into the Git repository, AHP+ ensures that this state information is naturally versioned, branched, and synchronized alongside the code. This design draws from the "Infrastructure as Code" philosophy — transforming implicit knowledge that previously lived in ephemeral sessions into trackable, reversible explicit files. Every project state change forms a Git commit, allowing developers to precisely view the project context at any point in time and use Git's diff capabilities to compare decision changes across different stages. This seamless integration with existing toolchains significantly lowers the adoption barrier.

The protocol persistently stores the following key information:

• Current State: The project's latest progress and pending tasks
• Decision Records: Architectural choices, technical approaches, and their rationale
• Evidence Chain: Test results, performance data, and other evidence supporting decisions
• Checkpoints: Important project milestone markers
• Handoff Information: Context for transferring between AI tools

The "Decision Records" feature actually continues an important practice tradition in software engineering — Architecture Decision Records (ADR). ADRs were proposed by Michael Nygard in 2011, with the core idea of recording every important architectural decision in a structured document format, including the decision context, alternatives considered, the final choice, and its reasoning. In traditional development, many architectural decisions are buried in meeting notes, Slack messages, or developers' heads, and new team members often don't understand "why it was designed this way." AHP+ extends this practice to AI collaboration scenarios: not only do human developers need to understand historical decisions, but AI tools taking over the project equally need this context to avoid re-discussing already settled approaches or overturning existing sound designs.

Enterprise-Grade Enhancements in Version 1.4.1

The latest version 1.4.1 introduces several enterprise-grade features, upgrading AHP+ from a personal tool to a team collaboration platform.

Shared Project Spaces

Supports multiple people collaborating on the same project, where each member can use their preferred AI tool while sharing a unified project knowledge base. This breaks the binding between "AI tool choice" and "project continuity."

Bounded Inter-AI Consultation

Allows one AI assistant to request specialized advice from another AI within a specific scope (e.g., having a frontend-focused AI consult a backend expert), while using "bounded" restrictions to prevent the consultation chain from expanding infinitely and causing chaos.

This feature reflects an important trend in current AI Agent system design — Multi-Agent Collaboration. In this architecture, different AI Agents are assigned different specialist roles (such as frontend expert, database expert, or security auditor), and they can consult each other to solve cross-domain problems. However, unrestricted inter-Agent communication can lead to "consultation storms" — Agent A consults Agent B, B consults C, and C circles back to consult A, creating circular dependencies or exponentially growing communication overhead. AHP+ addresses this through "bounded" restrictions, essentially setting depth limits and scope constraints on the multi-agent communication graph to ensure consultation behavior remains controllable and efficient. This shares similarities with the "Circuit Breaker Pattern" in distributed systems.

Validated Handoffs

When switching AI tools, the new tool must first verify and confirm the current project state, ensuring development doesn't continue based on outdated information. This is similar to a "health check" mechanism in software development.

Encrypted Cross-Device Transfer

Supports secure synchronization of project context across office computers, home devices, and cloud-based IDEs, protecting sensitive architectural information and business logic.

Quick Start: Initialize with a Single Command

Installation and usage are straightforward — just one command to initialize in your project:

npx @jossuealcala/ahp-plus@1.4.1 setup .

This command creates the necessary configuration files and directory structure in the project root. Afterward, all AI tools that support the AHP+ protocol can read and update this state information.

The project uses the Apache-2.0 open-source license and is hosted on GitHub (github.com/jossuealcacao-exe/ahp_plus), allowing developers to freely use, modify, and contribute code. The choice of Apache-2.0, a permissive open-source license, carries significant strategic implications — it allows anyone to use, modify, and distribute the code with virtually no restrictions, and even integrate it into commercial closed-source products. The only major requirement is retaining the original copyright notice and license text. Compared to Copyleft licenses like GPL that require derivative works to also be open-sourced, Apache-2.0 is much more enterprise-friendly. For a project like AHP+ that aspires to become an industry-standard protocol, this choice eliminates legal concerns for AI tool vendors (such as Cursor, Windsurf, etc.) about integrating AHP+ support into their products, maximizing the protocol's chances of widespread adoption.

Typical Use Cases for AHP+

AHP+ is particularly well-suited for the following types of developers and teams:

• Tool Experimenters: Those who frequently try new AI coding assistants and need to maintain project continuity
• Hybrid Workflows: Developers switching between local IDEs and online tools
• Team Collaboration: Teams where members use different AI tools but need to share project knowledge
• Long-Term Projects: Complex projects requiring sustained development over weeks or months

From a broader perspective, AHP+ represents an attempt at standardizing AI-assisted programming tools. The current AI coding tool market is highly fragmented, with each tool having its own approach to context management. If a unified project state exchange protocol can be established, it would significantly reduce tool-switching costs and promote healthy ecosystem development.

Notably, AHP+ didn't emerge in isolation — it's part of a broader wave of AI tool interoperability. In late 2024, Anthropic released MCP (Model Context Protocol), aimed at standardizing how AI models connect to external data sources and tools, which has already gained support from multiple companies including OpenAI. Google also introduced a similar A2A (Agent-to-Agent) protocol for inter-Agent communication. However, these protocols primarily address real-time connections between AI and tools/data, while AHP+ focuses on a relatively uncharted territory — persistent storage and cross-tool transfer of project-level state. If MCP is like AI's "USB port" (plug-and-play device connectivity), then AHP+ is more like AI's "project archive" (persistently storing and transferring project memory). They solve complementary problems and will likely converge in the future.

Current Challenges and Community Discussion Directions

The author specifically solicited feedback from "developers who frequently switch between AI coding tools" upon release. The project is still in its early stages, and several key issues deserve attention:

1. Protocol Standardization: How can mainstream AI tools be encouraged to natively support the AHP+ protocol?
2. Privacy and Security: How can fine-grained access control for sensitive information be implemented in team collaboration scenarios?
3. Conflict Resolution: How should merge strategies be designed when multiple people modify project state simultaneously?
4. Performance Optimization: State files for large projects may grow rapidly, requiring reasonable archiving and compression mechanisms.

Despite these challenges, both the problem AHP+ raises and its proposed solution carry real-world significance. As AI coding tools become more widespread, context management will become a critical factor affecting the development experience. This open-source project may well inspire more discussion and practice around "AI tool interoperability."