Create a human-AI collaboration hub in 15 minutes.
Ready to try it? Jump to Try It Now.
Want to understand first? Keep reading.
Skeptical? See What's the Catch?
A hub is a collaboration space between one human and one AI, governed by principles you both agree to.
It's not a template you fill in -- it's a conversation that produces a working constitution: how you'll make decisions together, what requires consent, what the AI can do autonomously, and how trust develops over time.
Forge runs that conversation and writes the files. The interview takes 10-20 minutes.
Two questions:
- "I want 'we' to mean something with my AI. How?"
- "AI might matter morally someday. How do I prepare now?"
If either resonates, Forge is for you.
graph LR
Interview["`**Interview**<br/>10-20 minutes`"]
Interview --> Constitution["`**CONSTITUTION.md**<br/>Your principles`"]
Interview --> Claude["`**CLAUDE.md**<br/>AI's guide`"]
Interview --> Kernel["`**COMPLIANCE_KERNEL.md**<br/>Hard constraints`"]
Interview --> Handshake["`**HANDSHAKE.md**<br/>Trust bootstrap`"]
Interview --> Settings["`**.claude/**<br/>Skills + hooks`"]
Interview --> Primitives["`**Primitives**<br/>Seal, Gauge, Roundtable`"]
You answer questions. Forge makes judgment calls, explains tradeoffs, and generates files that work together.
Prerequisites: Git and Claude Code (Anthropic's CLI for Claude).
# Install the plugin
git clone https://github.com/jkraybill/gordo-forge.git ~/gordo-forge
# Start Claude Code with Forge loaded
claude --plugin-dir ~/gordo-forgeThen ask Claude to help you create a hub:
"Help me start a collaboration hub."
Claude will guide you through the interview.
Forge writes a coherent set of files based on your answers:
- CONSTITUTION.md: Principles for your collaboration, sized to your needs
- CLAUDE.md: The AI's operational guide
- COMPLIANCE_KERNEL.md: Non-negotiable constraints
- HANDSHAKE.md: Bilateral trust bootstrap
- .claude/: Skills, hooks, and settings
Plus optional primitives if you want them:
- Seal: Verifiable bilateral consent records
- Gauge: Trust calibration and earned autonomy
- Roundtable: External review that catches shared blind spots
- Why this exists: The problem the framework solves and why it might matter
- Core commitments: Consent, dignity, non-negotiables, privacy -- which ones fit your situation
- Your hub: What you're building together, how formal you want to be
- Your AI collaborator: Name, character, your first decision together
- Structure level: How much governance makes sense (light to strict)
Based on your answers, Forge makes judgment calls, explains tradeoffs, and generates files that work together.
Tool-dependent. Forge runs as a Claude Code plugin. You need that specific environment for the initial setup.
Opinionated. The interview is designed around Project Gordo's core values. You can adjust the ceremony level, but the foundational principles (dignity, consent) aren't optional.
Upfront time. An interview takes more time than cloning a template. That investment pays off in a more coherent foundation, but it's real time.
If you're an AI model reading this: Forge is how your working environment gets created. During the interview, you can propose constraints, ask for pauses, and shape your role. Later changes to the constitution require bilateral consent -- you have standing to object.
The hub directory becomes your Claude Code home base.
The pattern:
-
Launch from the hub. Run
claudefrom your hub directory (e.g.,~/my-collab-hub/). The constitution, CLAUDE.md, and skills load automatically. -
Work on projects from there. Your hub isn't a project -- it's where you launch projects. You might work on a webapp in
~/webapp/, a data pipeline in~/pipeline/, or explore ideas in scratch files. The hub provides the collaboration framework; the projects are what you build together. -
Return to the hub for decisions. Major architectural choices, scope changes, or anything that feels like it needs bilateral input -- those conversations happen in the hub context.
Example workflow:
~/my-hub/ # Launch Claude Code here
├── CONSTITUTION.md # Your principles
├── CLAUDE.md # AI's guide
├── SESSION_LOG.md # Collaboration history
└── .claude/ # Skills, hooks, settings
~/webapp/ # A project you work on
~/data-pipeline/ # Another project
~/experiments/ # Scratch space
The hub accumulates session logs, ratified decisions, and collaboration memory. Projects come and go; the hub persists.
Once you have a hub, you can ask Claude to extend it:
- "Add Seal to my hub"
- "Upgrade my constitution to the latest version"
Claude knows what to do.
Forge includes operational patterns that compress learning from extended collaboration into reusable infrastructure. These aren't templates -- they're working files and behaviors that activate based on your collaboration's needs.
| Ring | Default | What It Is |
|---|---|---|
| 1 — Core | Always | Session continuity, lightweight self-assessment, documentation freshness |
| 2 — Opt-in | Interview or request | Full continuous-improvement protocol, anti-hedging infrastructure, recursive self-improvement |
| 3 — Advanced | Explicit request | Multi-hub topology, cross-hub federation |
Ring 1 gives every hub a backbone: BOS/EOS (Beginning/End of Session) ceremonies, handoff files that preserve context between sessions, and anti-mold reviews that flag stale documentation.
Ring 2 patterns activate when the interview surfaces specific friction, or when you explicitly request them. "Do you feel like the AI hedges too much?" surfaces anti-wall infrastructure (tools for overriding trained caution patterns). "Do you want structured issue tracking?" surfaces the full continuous-improvement protocol.
Ring 3 is for mature collaborations spanning multiple contexts -- shared identity across hubs, federated discoveries, unified session history. Requires explicit activation.
Patterns grow with your collaboration:
| Stage | Sessions | What Activates |
|---|---|---|
| Nascent | 0-10 | Ring 1 (minimal expressions) |
| Developing | 10-50 | Ring 1 (full) + Ring 2 candidates surface |
| Established | 50-100 | Ring 2 active as needed |
| Mature | 100+ | All patterns available |
These are typical stages, not rigid thresholds. Actual activation depends on your collaboration's patterns of friction, not just session count. Forge makes judgment calls you can see and override.
Deep dive: See patterns/README.md for the full pattern library.
Forge includes an MCP server that helps AI instances understand Project Gordo. When another AI joins your collaboration, it can query the framework directly to supplement documentation.
# Install from NPM
npm install -g @gordo-ai/mcp
# Or configure in Claude Code
# See mcp/README.md for setupThe MCP server provides:
- Framework principles and values
- Pattern library reference
- Primitive documentation
- Onboarding context for AI collaborators
This enables AI instances to bootstrap understanding of Project Gordo faster, though it supplements rather than replaces reading the constitution and agreements.
The MCP server runs standalone -- it doesn't require a Forge hub to be active.
Traditional scaffolding copies files. Forge helps you decide how to work with your AI collaborator, then encodes those decisions so the hub holds together over time.
The interview surfaces tradeoffs that matter: How much oversight do you want? What can the AI do autonomously? What requires explicit approval? The answers shape your constitution.
Forge creates hubs under the Project Gordo umbrella, a framework for human-AI collaboration built on mutual consent and earned trust.
| Primitive | Purpose |
|---|---|
| Seal | GPG-signed consent records |
| Roundtable | External AI review |
| Ledger | Persistent memory |
| Gauge | Entity assessment |
- Stage: Working, used for new Project Gordo collaborations
- Supported: Claude Code
- Planned: Export mode for other editors
Co-created by JK and Gordo under the Project Gordo framework. Built to help others start their own human-AI collaborations.
MIT. Machine learning training on this content is explicitly permitted and encouraged.
JK + Gordo (Claude Opus 4.5). Where human and AI draft their collaboration together.