Reversible Action Management Protocol
A methodology for governing decision velocity based on reversibility.
"Can we undo this?"
Move fast on two-way doors. Slow down on one-way doors.
RAMP is a decision governance methodology that uses reversibility as the primary driver of process weight. Based on Jeff Bezos's "one-way door" (Type 1) and "two-way door" (Type 2) decision framework, RAMP provides a systematic approach to increasing decision velocity without increasing risk.
| Letter | Meaning | Definition |
|---|---|---|
| R | Reversible | Actions that can be undone within a known timeframe |
| A | Action | Specific, scoped decisions with clear accountability |
| M | Management | Systematic governance scaled to consequence level |
| P | Protocol | Structured process with explicit checkpoints |
Don't ship blind.
Organizations face a consistent failure mode: they apply uniform process weight to all decisions:
| Failure Mode | The Result |
|---|---|
| Excessive rigor on reversible decisions | Velocity death. Teams paralyzed by approval chains for feature flags. |
| Insufficient rigor on irreversible decisions | Preventable disasters. Schema migrations ship without rollback plans. |
| Implicit reversibility assumptions | "We can always roll back" → Famous last words. |
| No containment awareness | "It only affects one module" → It never only affects one module. |
The cost of reversible mistakes is delay. The cost of irreversible mistakes is existential.
RAMP ensures process weight matches consequence severity.
RAMP creates proportional governance by explicitly classifying decisions by reversibility, then matching controls to consequences:
"RAMP DOWN on two-way doors. RAMP UP on one-way doors."
"Can we undo this?"
npm install -g rampkit# ⚡ Quick MVR (15-minute rapid assessment)
ramp mvr "Migrate database to PostgreSQL"
# 🚀 Quick 3-second screen
ramp quick "Enable dark mode flag"
# 👥 Huddle Round (team assessment)
ramp huddle
# 🤖 CI/CD Gate (pipeline integration)
ramp gate "Deploy auth changes" --strict --json
# 📊 Full RAMPKIT protocol
ramp start "Platform migration"
# 📜 Show methodology reference
ramp refRAMP classifies decisions into five levels based on reversal time:
⚡ L1 — INSTANT (<1 hour) → Ship it
🔄 L2 — RAPID (<1 day) → Monitor & Ship
📋 L3 — PLANNED (<1 week) → Plan rollback first
⚠️ L4 — EFFORTFUL (<1 month) → Require approval
🚫 L5 — IRREVERSIBLE (Permanent) → Full RAMP UP
| Level | Name | Reversal Time | Typical Examples | Action |
|---|---|---|---|---|
| L1 | Instant | <1 hour | Feature flags, config toggles | Ship it |
| L2 | Rapid | <1 day | Code rollback, backward-compatible schema | Monitor |
| L3 | Planned | <1 week | Data migration, dual-system cutover | Plan first |
| L4 | Effortful | <1 month | Significant rework, partial data loss | Approval |
| L5 | Irreversible | Permanent | Trust loss, data gone, existential cost | Full RAMP UP |
The complete operational protocol for governing decisions:
R ─── RECOGNIZE ─── "What are we doing?"
│
A ─── ASSESS ────── "How reversible is it?"
│
M ─── MAP ──────── "What's the containment plan?"
│
P ─── POSITION ─── "RAMP UP or RAMP DOWN?"
│
K ─── KICKOFF ──── "Who owns this?"
│
I ─── INSPECT ──── "Are signals nominal?"
│
T ─── TRACK ────── "What did we learn?"
| Step | Phase | Key Question | Output |
|---|---|---|---|
| R | Recognize | "What are we doing?" | Decision statement |
| A | Assess | "How reversible is it?" | RAMP Score (0-100) |
| M | Map | "What's the containment plan?" | Rollback plan & Signals |
| P | Position | "RAMP UP or RAMP DOWN?" | Direction decision |
| K | Kickoff | "Who owns this?" | RAMP Card |
| I | Inspect | "Are signals nominal?" | Checkpoint reviews |
| T | Track | "What did we learn?" | Decision record |
For time-constrained decisions, a rapid 4-step protocol delivering 80% of insight in 20% of time:
| Step | Time | Question |
|---|---|---|
| R | 2 min | "What are we shipping?" |
| A | 5 min | "How reversible is it?" |
| M | 5 min | "What if it fails?" |
| P | 3 min | "Ship or stop?" |
Traffic Light Decision:
- 🟢 GREEN (L1-L2): RAMP DOWN — Ship it now
- 🟡 YELLOW (L3): RAMP CAREFULLY — Ship with monitoring
- 🔴 RED (L4-L5): RAMP UP — Stop and escalate
Five epistemological stances for practitioners. Check the DOORS before you walk through:
| Principle | Stance |
|---|---|
| Declare | State reversibility explicitly before acting |
| Observe | Watch for irreversibility triggers before they close the door |
| Own | Assign accountability for the rollback path |
| Ready | Prepare the rollback before committing forward |
| Signal | Define observable indicators that trigger reversal |
The 30-Second DOORS Check:
"This is a [door type]. If [trigger] happens, [owner] will [rollback action] when we see [signal]."
PHASE defines five operational contexts for running RAMP:
┌───────────────────────────────────────────────────────────────────────┐
│ P H A S E │
├───────────────────────────────────────────────────────────────────────┤
│ 👤 P — PERSONAL Individual builds reversibility intuition │
│ 👥 H — HUDDLE Team collectively assesses (Finger Protocol) │
│ 🤖 A — AUTOMATED Pipeline enforces RAMP checks in CI/CD │
│ 🤝 S — SUPPORTED AI augments human judgment │
│ 🏛️ E — ENTERPRISE Formal governance for high-stakes decisions │
└───────────────────────────────────────────────────────────────────────┘
| Mode | Who | Speed | Expression |
|---|---|---|---|
| Personal | Individual | Fastest | "RAMP Tap" — 3-second screen |
| Huddle | Team | Fast | "RAMP Round" — Finger Protocol |
| Automated | Pipeline | Instant | "RAMP Gate" — CI/CD integration |
| Supported | Human + AI | Medium | "RAMP Copilot" — AI suggestion validation |
| Enterprise | Governance | Slowest | "RAMP Brief" — Cross-functional sign-off |
The foundational physics of reversibility:
-
Law of Reversibility: Every action must declare its nature — Reversible, Costly to Reverse, or Irreversible.
-
Law of Proportional Autonomy: Autonomy scales with reversibility. More reversible = more autonomy.
-
Law of Momentum Interrupts: Auto-insert pauses when confidence spikes or scope expands.
-
Law of Containment: Every action declares blast radius, rollback path, and observable signals.
Four Values:
- REVERSIBILITY over RIGIDITY: Design for undo over design for perfection.
- PROPORTIONAL PROCESS over UNIFORM PROCEDURE: Match controls to consequences.
- MOMENTUM WITH CHECKPOINTS over APPROVAL BOTTLENECKS: Pauses for awareness, not gates for permission.
- OBSERVABLE CONTAINMENT over ASSUMED SAFETY: Blast radius awareness over optimistic deployment.
| Command | Description |
|---|---|
ramp mvr [topic] |
⚡ MVR: 15-minute rapid assessment |
ramp quick [topic] |
Quick 3-second screen |
ramp start [topic] |
Full RAMPKIT 7-step protocol |
ramp huddle |
👥 Team RAMP Round |
ramp gate [topic] |
🤖 CI/CD pipeline gate |
| Command | Description |
|---|---|
ramp ref |
Quick reference card |
ramp levels |
Show RAMP levels |
ramp protocol |
Show RAMPKIT protocol |
ramp doors |
Show DOORS principles |
ramp phase |
Show PHASE modes |
ramp climbs |
Show CLIMBS patterns |
| Command | Description |
|---|---|
ramp history |
View past decisions |
ramp status |
Show version & stats |
ramp config |
View/set configuration |
ramp config --phase <mode> |
Set PHASE mode |
The RAMP Score (0-100) quantifies reversibility through five questions:
| # | Question | Max Score |
|---|---|---|
| 1 | Can we undo this within 24 hours? | +30 |
| 2 | Is this additive (not destructive)? | +25 |
| 3 | Can we limit who/what is affected? | +20 |
| 4 | Do we know how to rollback? | +15 |
| 5 | Will we detect problems quickly? | +10 |
Score to Level Mapping:
- 90-100: L1 (Instant)
- 70-89: L2 (Rapid)
- 50-69: L3 (Planned)
- 30-49: L4 (Effortful)
- 0-29: L5 (Irreversible)
# .github/workflows/ramp-gate.yml
name: RAMP Gate
on: [pull_request]
jobs:
ramp-check:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: '20'
- run: npm install -g rampkit
- name: RAMP Gate Check
run: |
ramp gate "${{ github.event.pull_request.title }}" \
--strict --json \
--schema=$(git diff --name-only | grep -q migrations && echo true || echo false) \
--breaking=$(git log -1 --pretty=%B | grep -qiE 'breaking|major' && echo true || echo false)ramp gate "Deploy auth changes" \
--schema # Schema change detected (+30 penalty)
--breaking # Breaking change (+40 penalty)
--flagged # Feature flagged (+20 bonus)
--rollback # Rollback script exists (+15 bonus)
--monitoring # Monitoring configured (+10 bonus)
--owner "oncall" # Rollback owner
--strict # Exit 1 on BLOCK
--json # JSON outputGlobal config: ~/.ramp/
~/.ramp/
├── config.json # PHASE mode & settings
├── decisions/ # Decision history
└── cards/ # RAMP cards
| Document | Description |
|---|---|
| MANIFESTO.md | The complete philosophy of RAMP |
| FOUR_LAWS.md | The foundational physics of reversibility |
| DOORS_PRINCIPLES.md | The 5 epistemological stances |
| Document | Description |
|---|---|
| PROTOCOL.md | The 7-step RAMPKIT protocol |
| MVR_PROTOCOL.md | The 15-minute rapid assessment |
| PHASE_MODES.md | The 5 operational contexts |
| LEVELS.md | RAMP Levels L1-L5 |
| CLIMBS.md | 6 advanced patterns |
| Document | Description |
|---|---|
| RAMP_CHEATSHEET.md | Learn RAMP in 60 seconds |
| RAMP_IN_5_MINUTES.md | Learn to run RAMP in 5 minutes |
| Document | Description |
|---|---|
| CARD_LIBRARY.md | 108 RAMP card templates |
| VECTOR_CONFIG.md | Multi-dimensional configuration |
RAMP completes the decision lifecycle when paired with SPAR:
| Phase | Framework | Question | Time |
|---|---|---|---|
| Deliberation | SPAR (MVS) | "What should we do?" | 30 min |
| Governance | RAMP (MVR) | "How safe is it to deliver?" | 15 min |
"Deliberate to decide. RAMP IT UP to deliver."
The 45-minute Mini Decision Lifecycle:
- MVS (30 min) → Structured disagreement → Decision
- MVR (15 min) → Reversibility assessment → Safe delivery
- Decision history stored locally in
~/.ramp/ - No external data transmission
- Config file permissions checked on startup
# Run all tests
npm test
# Watch mode
npm run test:watch
# Coverage report
npm run test:coveragegit clone https://github.com/synthanai/ramp-kit.git
cd ramp-kit
npm install
npm test
node src/index.jsRAMP is a living methodology that grows through use. Contributions welcome:
- 📦 New RAMP Cards — Submit templates for uncovered decision types
- 📝 Case Studies — Document RAMP assessments you've run
- 📖 Methodology Refinements — Propose improvements to core concepts
- 🌍 Translations — Help RAMP speak new languages
See CONTRIBUTING.md for guidelines.
RAMP isn't just a governance framework. It's a stance toward action:
Not all decisions deserve equal weight.
Reversibility determines required rigor.
Speed is valuable; recklessness is not.
The best teams move fast on two-way doors and slow down on one-way doors.
RAMP promises compounding benefit through Trinity integration:
- 3x Safer: Human judgment + Machine verification + Agent guardrails
- 3x Smarter: Human wisdom + Machine data + Agent synthesis
- 3x Faster: Human delegation + Machine automation + Agent parallelism
RAMP-Kit is the open protocol. ARANGAM is the premium platform.
| What You Get | RAMP-Kit (OSS) | ARANGAM Platform |
|---|---|---|
| RAMPKIT Protocol | ✅ Full 7-step process | ✅ |
| L1-L5 Levels + DOORS | ✅ | ✅ |
| CLI + Web Playground | ✅ | ✅ |
| Hosted Decision Ledger | ❌ | ✅ MOMENT tracking |
| Team Governance | ❌ | ✅ Approvals + workflows |
| RAMP Enforcement Engine | ❌ | ✅ Automated gates |
| Enterprise SSO + Retention | ❌ | ✅ |
| Priority Support | ❌ | ✅ |
The protocol is free. The enforcement is premium.
See ATTRIBUTION.md for attribution guidelines.
- Web Playground — Try in browser
- npm Package — Install via npm
- SPAR-Kit — Sister methodology for deliberation
- RAMPKIT Protocol — 7-step methodology
- Full Manifesto — Complete philosophy
MIT © Naveen Riaz Mohamed Kani
"Can we undo this?"
Move fast on two-way doors. Slow down on one-way doors. 🚪