Semantic continuity for AI systems — without lock-in, without identity persistence.
ContinuumPort is an open protocol for portable semantic context. It enables the transfer of user intent, task constraints, and progress state between AI systems, while explicitly refusing to transport identity, emotion, or behavioral conditioning.
- The Big Picture: Start this README.md for a high-level overview.
- Philosophy & Ethics: Read DESIGN_RATIONALE.md and docs/boundaries.md to understand the "why".
- Deep Theory: Explore docs/essays/ for the foundational concepts behind the protocol.
- Technical Rules: Check the spec/ folder for normative implementation requirements.
- Live Examples: See examples/quickstart/ for a Python-based reference of CP-Core in action.
- For a deeper discussion on why continuity matters more than raw compute, see AI_Cognitive_Reconstruction_Cost.md.
-
The Semantic RAW — Why CP-Core is a digital negative of intent
ContinuumPort is built on the principle that Continuity ≠ Presence. We believe that transporting dialogue history is a bottleneck for both privacy and performance.
- Why We Don't Move the Dialogue — Understanding the "Extractable Core" vs. "Conversation Noise".
- Restraint by Design: We deliberately refuse to standardize identity or emotion, focusing strictly on task-related semantic state.
- An Open protocol (MIT licensed).
- Privacy-by-design (standardized exclusion of identity).
- Model-agnostic and platform-independent.
- A Transport container for task state (CP-Core).
- NOT a prompting strategy: Prompt construction is explicitly out of scope.
- NOT a memory system or an identity layer.
- NOT a behavioral optimization engine or a "consciousness" simulator.
- Design Rationale — Why these limits exist
- Boundaries — What we deliberately do NOT standardize
- Emergent Behaviors — Allowed but non-guaranteed behaviors
Protocol Specification Versioning — Implementation and versioning rules
# Clone the repository
git clone https://github.com/giorgioroth/continuumport.git
cd continuumport
# Explore the documentation
cat DESIGN_RATIONALE.md
cat spec/regen-engine.md(Reference implementation and examples coming soon)
Current Status: Draft / Early Development
- ✅ Core philosophy documented
- ✅ Boundaries defined
- ✅ Regen Engine spec published
- 🚧 CP-Core format specification (in progress)
- 🚧 Reference implementation (planned)
- 🚧 Example containers (planned)
ContinuumPort deliberately refuses to standardize identity, emotion, or memory — even though these are technically feasible.
Only CP-Core format and minimal Regen behavior are normative. Everything else (embeddings, auth, optimizations) is implementation-specific.
A Regen Engine is conformant if and only if removing all non-normative layers does not change the semantic intent reconstructed from CP-Core.
Read the full rationale: DESIGN_RATIONALE.md
Allowed:
- Continuing work across different AI systems
- Switching models without losing task context
- Multi-agent collaboration on long-term projects
- Personal context ownership and portability
Prohibited:
- Identity persistence or "self" simulation
- Emotional continuity or attachment formation
- Behavioral conditioning or personality shaping
- Hidden data retention or opaque interpretation
- ContinuumPort is subject to mandatory non-abuse normative constraints. See /normative/NON_ABUSE.md.
Contributions are welcome, especially:
- Feedback on spec clarity
- Use case proposals
- Implementation suggestions
- Documentation improvements
For major changes, please open an issue first.
All contributions must respect ContinuumPort's core boundaries.
Towards a stable and widely adoptable v1.0 release.
-
Core philosophy & boundaries documented
-
Example CP-Core containers
(Multiple varied examples + quickstart guide available) -
Community RFC process
(Contribution guidelines and philosophical constraints in place) -
Reference Regen Engine implementation
(Planned – reference implementation coming soon) -
Validation tools
(Schema validation and conformance tests – contributions welcome) -
v1.0 stable release
(Finalized spec, implementations, and tools required)
Author: Gh. Rotaru (Giorgio Roth)
Email: [email protected]
X/Twitter: @continuumport
MIT License
ContinuumPort is open infrastructure. Free to use, fork, implement, and extend — within the documented boundaries.
ContinuumPort: continuity of work, never continuity of self.
Yes. And that is its greatest strength. ContinuumPort does not aim for structural complexity, but for normative restriction. While a standard "summary" is informal and often contaminated with behavioral instructions or persona drift, CP-Core is a strictly defined transport layer. It standardizes the data, not the formatting.
System prompts are model-dependent, fragile, and constitute a "prompting trick" rather than a robust architecture. ContinuumPort separates the Semantic State (the what) from the Regen Engine (the how). By treating task continuity as a data serialization problem, we achieve true multimodel portability. Prompt construction is explicitly out of scope for the protocol.
Its primary privacy contribution is the Prevention of Identity Leakage. By explicitly forbidding the storage of user style, emotional tone, or personal history, the protocol ensures that even if a container is intercepted, it contains only "work in progress," not a "psychological profile" of the user. We standardize the exclusion of identity.
A protocol is a contract, not a product. TCP/IP doesn't send emails; it moves packets. ContinuumPort moves semantic state. By separating the Transport Layer (CP-Core) from the Interpretation Layer (Regen Engine), we allow the ecosystem to build diverse, conformant engines that all speak the same semantic language.
The specification allows for extensions, but they are marked as Non-Normative. A Regen Engine is conformant if and only if removing all non-normative layers (tracking, embeddings, proprietary metadata) does not change the reconstructed semantic intent. We provide the standard that allows users to detect and strip away vendor lock-in.
Documentation is the product. CP-Core is the contract.
ContinuumPort: continuity of work, never continuity of self.