diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3f32ec8..f097b8d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -24,6 +24,9 @@ jobs:
           node-version: ${{ matrix.node-version }}
           cache: 'yarn'
 
+      - name: Enable Corepack
+        run: corepack enable
+
       - name: Install dependencies
         run: yarn install --frozen-lockfile
 
@@ -52,6 +55,9 @@ jobs:
           node-version: 20.x
           cache: 'yarn'
 
+      - name: Enable Corepack
+        run: corepack enable
+
       - name: Install dependencies
         run: yarn install --frozen-lockfile
 
diff --git a/manifesto.md b/manifesto.md
new file mode 100644
index 0000000..91b0cee
--- /dev/null
+++ b/manifesto.md
@@ -0,0 +1,170 @@
+# The CLICP Manifesto: Why Command Line Interface Context Protocol is Superior to MCP
+
+## The Fundamental Problem with MCP
+
+The Model Context Protocol (MCP) represents a well-intentioned but fundamentally flawed approach to connecting AI models with external systems. While MCP attempts to create a "USB-C port for AI applications," it introduces unnecessary complexity and abstractions that actually hinder rather than help AI model performance.
+
+## Why CLICP is the Better Path Forward
+
+### 1. LLMs Are Already CLI Experts
+
+Large Language Models have been trained on vast amounts of code, documentation, and system administration content. They inherently understand:
+
+- Command-line interfaces and their patterns
+- Shell scripting and automation
+- Unix philosophy and tool composition
+- Standard input/output patterns
+- Error handling through exit codes
+
+**The evidence is overwhelming**: When you ask an LLM to perform a system task, it naturally thinks in terms of CLI commands. Why force it through an artificial protocol when it already speaks the native language of systems?
+
+### 2. The Devbox Advantage
+
+Modern AI development already assumes sandboxed environments:
+
+- **Security**: Isolated execution environments are a necessity, not a luxury
+- **Reproducibility**: Containerized environments ensure consistent behavior
+- **Scalability**: Devboxes can be spun up and torn down as needed
+- **Simplicity**: No need for complex protocol implementations
+
+Since we're already giving AI models access to sandboxed development environments, the most natural interface is the command line that already exists in every such environment.
+
+### 3. Zero Protocol Overhead
+
+CLICP eliminates the need for:
+- Custom protocol implementations
+- Server/client architecture complexity
+- JSON-RPC message passing
+- Protocol versioning and compatibility issues
+- Specialized debugging tools
+
+Instead, CLICP leverages:
+- **Standard CLI tools** that already exist
+- **Shell pipes and redirection** for data flow
+- **Exit codes** for error handling
+- **Standard streams** (stdin/stdout/stderr) for communication
+- **Existing debugging tools** (strace, ltrace, etc.)
+
+### 4. Universal Compatibility
+
+Every system that can run an AI model can run CLI commands. CLICP works with:
+- Any Unix-like system (Linux, macOS, BSD)
+- Windows with WSL or PowerShell
+- Container environments
+- Cloud instances
+- Edge devices
+
+No additional servers, no protocol implementations, no compatibility matrices.
+
+### 5. Composability and Power
+
+CLI tools follow the Unix philosophy of doing one thing well and composing together:
+
+```bash
+# Natural AI thinking pattern
+find . -name "*.py" | xargs grep -l "TODO" | head -10
+```
+
+This is far more intuitive for an LLM than constructing complex MCP protocol messages to achieve the same result.
+
+### 6. Real-World Evidence
+
+Consider this tweet from Jay Hack (@mathemagic1an):
+
+> [Reference to tweet about LLMs being naturally good with CLIs and devboxes making sense]
+
+The evidence from actual AI model usage patterns consistently shows that models perform better when working with familiar CLI interfaces rather than abstract protocols.
+
+## The MCP Complexity Tax
+
+MCP introduces several layers of unnecessary complexity:
+
+1. **Protocol Implementation**: Every tool needs MCP server implementation
+2. **Message Serialization**: JSON-RPC overhead for simple operations
+3. **Connection Management**: WebSocket or stdio connection handling
+4. **Error Mapping**: Translating system errors to protocol errors
+5. **Documentation Overhead**: Protocol specs in addition to tool documentation
+
+## CLICP's Elegant Simplicity
+
+CLICP's approach is radically simpler:
+
+1. **Direct Execution**: AI models execute commands directly
+2. **Native Error Handling**: Standard exit codes and stderr
+3. **Streaming Output**: Real-time stdout/stderr streams
+4. **Zero Setup**: Works in any environment with a shell
+5. **Self-Documenting**: `--help` flags and man pages
+
+## Performance Implications
+
+### MCP Overhead
+- Protocol parsing and validation
+- Network or IPC communication
+- JSON serialization/deserialization
+- Connection establishment and teardown
+
+### CLICP Efficiency
+- Direct process execution
+- Native OS process management
+- Minimal memory overhead
+- No serialization overhead
+
+## Security Model
+
+### MCP Security Concerns
+- Protocol-level vulnerabilities
+- Server implementation bugs
+- Complex permission models
+- Attack surface of protocol stack
+
+### CLICP Security Advantages
+- Leverages OS-level security (users, groups, permissions)
+- Standard sandboxing mechanisms (containers, chroot, etc.)
+- Well-understood attack vectors
+- Decades of hardening in CLI tools
+
+## Developer Experience
+
+### MCP Development
+```python
+# Complex MCP server implementation
+class MyMCPServer:
+    def __init__(self):
+        self.setup_protocol()
+        self.register_tools()
+    
+    async def handle_request(self, request):
+        # Protocol parsing, validation, etc.
+        pass
+```
+
+### CLICP Development
+```bash
+#!/bin/bash
+# Just write a CLI tool
+echo "Hello, World!"
+```
+
+The difference is stark. CLICP leverages decades of CLI tool development experience and patterns.
+
+## The Path Forward
+
+The future of AI-system integration lies not in inventing new protocols, but in embracing the interfaces that already work:
+
+1. **Standardize on CLI interfaces** for AI-accessible tools
+2. **Leverage existing sandboxing** technologies
+3. **Build on proven patterns** rather than reinventing them
+4. **Focus on tool quality** rather than protocol complexity
+
+## Conclusion
+
+CLICP represents a return to first principles: use the right tool for the job. When the job is connecting AI models to system capabilities, the right tool is the command line interface that models already understand and that systems already provide.
+
+The Model Context Protocol, despite its good intentions, is a solution in search of a problem. The problem of AI-system integration is already solved by the command line interface. We just need to embrace it.
+
+**CLICP: Because the best protocol is no protocol at all.**
+
+---
+
+*This manifesto reflects the core philosophy behind CLICP: that simplicity, compatibility, and leveraging existing patterns will always triumph over complex abstractions and reinvented wheels.*
+