| name | using-lope |
| description | Use Lope when cross-model perspective helps: multi-phase sprints, flow graphs, ask/review/vote/compare/pipe, team, lope memory, lope deliberate, gate/check, update, or Headroom setup. Trigger on 3+ phases, consequential multi-file work, second opinions, artifact review, consensus/SARIF, ADR/PRD/RFC/build-vs-buy/migration, A/B or yes/no choices, pipes, roster changes, updates, or Headroom. Skip trivial single edits, pure conversation, urgent firefighting. |
Using Lope
Lope is a multi-CLI ensemble for AI work. Any AI CLI drafts, any AI CLI validates, multiple perspectives cover each other's blind spots. Core philosophy: no single-model blindspot. Current command surface covers structured sprints, single-shot fan-out, team management, autonomous graphs, persistent judgment, evidence gates, self-update, and optional Headroom setup:
| Mode | Skill | Shape of input/output |
|---|
negotiate | [lope-negotiate] | Goal → sprint doc with phases + verdicts |
execute | [lope-execute] | Sprint doc → implemented deliverables with per-phase review |
implement | [lope-implement] | Sprint doc + selected roster → zero-human sprint execution |
audit | [lope-audit] | Sprint doc → scorecard |
flow | [lope-flow] | DOT graph → autonomous multi-agent run (fan-out, consensus, fix-loops), bounded by visit caps |
ask | [lope-ask] | One question → N raw answers (one per model) |
review | [lope-review] | One file + focus → N raw critiques or consensus-ranked findings (--consensus) |
vote | [lope-vote] | Question + options → tally + winner |
compare | [lope-compare] | Two files + criteria → tally + winner |
pipe | [lope-pipe] | stdin → N raw answers (composable shell verb) |
team | [lope-team] | Natural-language roster management (add/list/remove/test) |
memory | [lope-memory] | Persistent finding store: stats / search / file / hotspots / forget |
deliberate | [lope-deliberate] | Scenario file + template (ADR/PRD/RFC/build-vs-buy/migration/incident) → 7-stage council artifact |
gate | shell: lope gate | Run project-defined objective evidence gates and compare against a baseline |
check | shell: lope check | CI-friendly one-shot run of objective evidence gates |
update / upgrade | shell: lope update | Self-update a git checkout and refresh installed host skills |
headroom | [lope-headroom] | Configure optional Headroom compression for bulky Lope / agent outputs |
help | [lope-help] | Print the complete reference via lope docs |
ask, review, vote, compare, and pipe are the lightweight verbs — no sprint, no phases, no validator retry loop. team manages the roster. flow shapes autonomous collaboration. lope memory and lope deliberate turn raw fan-out into durable judgment. gate / check run deterministic evidence commands from the project. update keeps the git checkout and host skills current. The cross-cutting flags --consensus, --synth, --remember, --brain-context, --brain-log, --divide, and --roles are opt-in.
Engineering execute/implement runs include minimality audit by default. Agents should expect Lope to prefer existing code, stdlib/native features, and the smallest safe custom code, and to have quality-stage validators flag material over-engineering. This is not part of gate/check because those commands run deterministic evidence checks. Disable with LOPE_MINIMALITY=off; enforce material bloat with LOPE_MINIMALITY=enforce.
When this skill triggers, consider which command shape fits — don't force every request into negotiate.
How the user will invoke lope
Two paths — you must handle both:
1. Explicit slash command. The user types /lope-negotiate "Add JWT auth". Straightforward. Route to /lope-negotiate and follow that skill's steps.
2. Natural language. The user describes what they want in prose. They do NOT type a slash command. You recognize the shape of the request and invoke lope on their behalf. This is the common case — users don't remember slash commands, they just talk. Your job is to map the natural language to the right lope invocation.
Examples of natural-language triggers and the invocation you should run:
Plan/structure work → negotiate:
| User says | You invoke |
|---|
| "Let's plan the auth refactor with JWT refresh rotation" | lope negotiate "Add JWT auth with refresh token rotation" --domain engineering |
| "Negotiate a sprint with gemini and opencode to draft 3 blog posts about lope" | lope negotiate "Draft 3 blog posts about lope" --domain business |
| "I want to plan the Q4 marketing campaign carefully" | lope negotiate "Q4 marketing campaign" --domain business |
| "Let's do a systematic review of post-training RL papers" | lope negotiate "Systematic review of post-training RL papers" --domain research |
Cross-model Q&A → ask:
| User says | You invoke |
|---|
| "What do gemini and claude say about this approach?" | lope ask "<their question>" |
| "Get a second opinion across models" | lope ask "<the question from context>" |
| "Ask all the CLIs if X is safe" | lope ask "Is X safe? <details>" |
| "Check with the other models before I commit this" | lope ask "<what they're about to do>" |
Cross-model file critique → review:
| User says | You invoke |
|---|
| "Review this file across models" | lope review <file> |
| "Have claude, gemini, and opencode check auth.py for security" | lope review auth.py --focus security |
| "Multi-model review of this PR diff" | lope review <path/to/diff> |
| "What would the other CLIs say about my config?" | lope review <config file> |
Structured vote with options → vote:
| User says | You invoke |
|---|
| "Yes/no from all the models — is X safe?" | lope vote "Is X safe?" --options "yes,no" |
| "Take a vote: 3.12 or 3.13 for a new project?" | lope vote "Python version for new project" --options "3.12,3.13" |
| "Ship, hold, or escalate — what do the CLIs say?" | lope vote "<context>" --options "ship,hold,escalate" |
A/B file comparison → compare:
| User says | You invoke |
|---|
| "Compare these two implementations" | lope compare <a> <b> |
| "Which is better for security — old or new?" | lope compare old.py new.py --criteria security |
| "Before/after bake-off across models" | lope compare <before> <after> --criteria "correctness, readability" |
Piped input → pipe:
| User says | You invoke |
|---|
| "Send this diff to every model" | gh pr diff | lope pipe |
| "Pipe the output into lope" | <command> | lope pipe |
| "Have every CLI look at this log" | cat log.txt | lope pipe |
Roster management → team:
| User says | You invoke |
|---|
| "Add openclaw to lope with my Tytus pod" | lope team add openclaw --url $OPENAI_BASE_URL/chat/completions --model openclaw --key-env OPENAI_API_KEY |
| "Add my local ollama (qwen3:8b) as a teammate" | lope team add my-ollama --cmd "ollama run qwen3:8b {prompt}" |
| "Remove codex from the team" | lope team remove codex |
| "Who's on lope?" / "list validators" | lope team list |
| "Test if the new mistral teammate works" | lope team test mistral |
| "Make openclaw the primary" | lope team add openclaw --url ... --force --primary |
Autonomous multi-agent graph → flow:
| User says | You invoke |
|---|
| "Run agents autonomously to build X, let them negotiate the approach" | lope flow init consensus then lope flow run .lope/flow/consensus.dot --task "build X" |
| "I want a propose → consolidate → implement → review loop, no babysitting" | lope flow run .lope/flow/consensus.dot --task "<goal>" |
| "Set up a fix-loop: implement, ensemble-review, retry until it passes" | lope flow init judge-loop then lope flow run .lope/flow/judge-loop.dot --task "<goal>" |
| "Show me / draw what the agents will do" | lope flow render <file>.dot -o flow.svg |
| "Change how the agents collaborate" | edit the .dot graph, then lope flow validate + lope flow run |
Pattern: plan → negotiate, ask → ask, critique artifact → review, predefined choices → vote, A/B files → compare, piped from shell → pipe, manage roster → team, shape an autonomous agent graph → flow, objective proof → gate/check, update Lope → update, configure compression → headroom. Don't force an ask-shaped request through negotiate — it wastes tokens and produces a sprint doc the user didn't want. Reach for flow when the shape of the collaboration (fan-out, consensus, loops) is the point and the run must be autonomous + bounded.
When to trigger
Reach for lope (any mode) whenever the user's request matches any of these:
- Multi-phase work. "Add auth with JWT refresh token rotation" has phases. →
negotiate then execute.
- Multi-file refactor. "Refactor the billing module to use events" touches many files. →
negotiate.
- Cross-model verification needed. Security-sensitive middleware, API contracts, migration scripts. If the user wants multiple models to sign off, use
negotiate for plans, review for finished artifacts.
- One-off cross-model question. "What do the other CLIs think of this approach?" →
ask. Fast, no sprint doc, no phases.
- Review an artifact. "Check this file / PR / spec across models." →
review <file>.
- Non-code domains.
--domain business (marketing, finance, ops) and --domain research (systematic reviews) work on negotiate. For business/research ask + review also apply — nothing is domain-locked.
When NOT to trigger
Skip lope — just do the work directly — when:
- Single-edit tasks. Fix a typo, rename a variable, add a missing import, change a hardcoded value. No sprint.
- Pure conversation. "What does this function do?", "Why did you choose X?", "Explain the architecture". No sprint.
- Trivial one-step operations. "Add a print statement here", "Remove this comment", "Update the version string". No sprint.
- The user already has a plan. If they said "here's the plan, now implement phase 2", execute that phase directly — don't re-negotiate.
- Exploratory questions. "What could we do about X?", "How should we approach this?". Have the conversation first. Only lope the agreed plan.
- Urgent fire-fighting. Production is down, user needs a fix in 10 minutes. Don't negotiate a sprint — patch the bug. Lope is for planned work.
Command surface
| Mode | Slash command / shell | When |
|---|
| Negotiate | /lope-negotiate <goal> | Before any multi-phase work. Drafts a structured sprint doc via multi-round validator review. |
| Execute | /lope-execute <sprint_doc> | After negotiation. Runs phases with validator-in-the-loop retry. |
| Implement | /lope-implement <sprint_doc> | After negotiation. Selects implementation/escalation agents once, then runs the sprint without human input. |
| Audit | /lope-audit <sprint_doc> | After execution. Generates the scorecard. |
| Ask | /lope-ask "<question>" | One question → N raw answers. No sprint, no phases. |
| Review | /lope-review <file> | Fan out a file review to all validators. --focus narrows the critique; --consensus ranks findings. |
| Vote | /lope-vote "<q>" --options A,B,C | Predefined choices → tally + winner. |
| Compare | /lope-compare <a> <b> | A/B file comparison. --criteria binds "better" to dimensions. |
| Pipe | <cmd> | lope pipe | stdin-fed fan-out. Composable shell verb. |
| Team | /lope-team add NAME ... | Roster management. Add/remove/list/test validators without editing JSON. |
| Flow | /lope-flow run <file.dot> | Autonomous DOT graph workflow. Agent / ensemble / shell-gate / judge nodes, conditioned edges, fan-out + loops, bounded by visit caps. |
| Memory | /lope-memory ... | Search persistent review findings, hotspots, and per-file history. |
| Deliberate | /lope-deliberate <template> <scenario> | 7-stage council for ADR / PRD / RFC / build-vs-buy / migration / incident decisions. |
| Gate | lope gate save/check | Save or compare project-defined objective evidence gates. |
Default flow for a planned task: negotiate → implement/execute → audit. Skip to one of the single-shot verbs (ask/review/vote/compare/pipe) when the user just wants multi-model output on a single prompt or artifact. Use team whenever the user's intent is to change who is ON the ensemble, not run it.
Domains
Pass --domain <name> on negotiate to switch validator role, artifact labels, and review task:
engineering (default) — code, software, infra, devopsbusiness — marketing, finance, ops, consulting, managementresearch — studies, systematic reviews, academic work
Supported validators
Lope auto-detects these on $PATH: Claude Code, OpenCode, Gemini CLI, Codex, Mistral Vibe, Aider, Ollama, Goose, Open Interpreter, llama.cpp, GitHub Copilot CLI, Amazon Q, pi (Traylinx), Qwen Code, and Agy. Custom providers via JSON config. At least two different ones are needed for a real ensemble — lope will still run with one but you lose the cross-model check.
Codex validator hygiene
Codex is useful in Lope, but only when isolated from interactive Codex startup config. If lope ask --validators codex times out while trivial prompts work, suspect Codex config pollution before declaring the validator down. Broken/slow MCP startup, high default reasoning, and large prompts can turn a validator call into an 8-minute run.
Fast diagnosis:
which lope codex
PYTHONPATH=$HOME/.lope python3 -m lope team test codex "Reply exactly: CODEX-OK" --timeout 60
PYTHONPATH=$HOME/.lope python3 -m lope ask --validators codex --timeout 120 "Reply exactly: CODEX-OK"
Expected Lope-side Codex invocation for validator work: codex exec --ignore-user-config --skip-git-repo-check -s read-only -c 'model_reasoning_effort="low"' <prompt>. This avoids loading user MCPs and keeps Codex as a validator, not a full interactive agent. If the installed adapter does not do this, patch ~/.lope/lope/validators.py before trusting Codex timings.
Use Codex with --timeout 600 only for slow specialist/API research, or split the question into narrow prompts. For fast ensemble checks, keep prompts small or use another validator.
If you invoke lope
Route through the dedicated slash commands, not by calling the Python module directly:
/lope-negotiate for drafting/lope-execute for normal phase running/lope-implement for zero-human sprint execution after roster selection/lope-audit for scoring/lope-ask for multi-model Q&A/lope-review for multi-model file critique/lope-vote for structured votes with predefined options/lope-compare for A/B file comparison with explicit criteria/lope-pipe for stdin-fed fan-out in shell pipelines/lope-team for adding, removing, listing, or testing validators/lope-flow for autonomous declarative graph workflows (fan-out, consensus, fix-loops)/lope-memory for persistent finding search / hotspots/lope-deliberate for ADR / PRD / RFC / build-vs-buy / migration / incident councils/lope-headroom for optional Headroom compression setup/lope-help for the full reference- shell
lope gate, lope check, and lope update for evidence gates and maintenance
Each slash command has its own SKILL.md with the full flow. Read that skill when you invoke it, don't paraphrase.
Caveman mode
Lope compresses validator prompts 50-65% by default via intelligent caveman mode. This is ON unless the user explicitly asks for verbose output. Don't disable it unless the task requires full prose (external writing, papers).
Minimality discipline
For engineering sprint execution, minimality audit is ON by default. Keep requirements, security, validation, accessibility, and data-loss handling intact; the point is to cut unnecessary dependency/abstraction/rewrite bloat, not to under-build. Business/research domains stay off unless explicitly enabled.
Do not
- Do not write wrapper scripts around lope. Lope is already a CLI. If the user says "draft me 3 blog posts using lope", you invoke
lope negotiate ... directly in a shell. You do NOT create a generate_blog_posts.py that imports lope, you do NOT build a pipeline harness, you do NOT "extend lope for this use case". Just run the CLI with the right arguments. The whole point of the multi-CLI ensemble is that lope is the harness — you don't need another one.
- Do not invent flags.
lope negotiate accepts --domain, --out, --max-rounds, --context, --context-file, --validators, --primary, --timeout, --parallel, and --sequential. There is no --host, no --title, no --output-format. If unsure, run lope negotiate --help — do not fabricate a flag.
- Do not invoke lope on single-edit tasks. It's overkill and wastes the user's time.
- Do not rubber-stamp a phase. Lope's entire point is catching what one model would miss — if you're the validator, be critical.
- Do not silently expand a phase's scope. If during work you discover a better approach, raise it with the user before folding it in.
- Do not ignore the lint. If
lope negotiate rejects your draft for placeholder language or empty artifact lists, fix the draft — do not try to bypass the lint with LOPE_LINT=off unless the user explicitly asks for it.
Runtime safety (v0.14.0)
Use --run-timeout for the whole command; --timeout remains a per-provider-call ceiling. Inspect the emitted request plan before large work and prefer compact evidence. Automatic shaping is bounded; use chunking only when the forecast fits --max-calls and --max-chunks. For abandoned work, run lope jobs list and preview lope jobs reap --dry-run. Never use pkill -f, killall, or process-name matching.
