# LoopFlow adapter demo Use this page as presenter notes for the LoopFlow owner. The short version: LoopFlow stays the control language; ctx becomes a permissioned recommendation sidecar that tells the loop which skills, agents, MCP tools, and user-owned LLM harnesses are worth loading before the next plan. ## 30-second pitch LoopFlow already owns the loop: `goal:`, `look at:`, plan, act, observe, reflect, and `done when`. ctx should not replace that. ctx should run before planning, read the same goal, verification checks, and failure context, and return a read-only JSON contract: - what the loop is allowed to load; - which skills, agents, MCP servers, and harnesses fit the current goal; - which related recommendations fit after the loop accepts or rejects part of a previous bundle; - the `ctx-mcp-server` command and tool list for MCP-aware runners; - a dry-run harness install command only when the user declares their own local/API model. ## Demo loop ```loop loop "select ctx capabilities": goal: mcp agent loop local ollama filesystem look at: the repo plan, AGENTS.md, and the last failure done when "pytest src/tests/test_loopflow_adapter.py -q" passes ctx grants: skills, mcps, harnesses each cycle: plan, then act, then observe when it fails: reflect, then plan again ``` ## Demo command Run ctx immediately before LoopFlow plans: ```bash python -m ctx.adapters.loopflow \ --goal "mcp agent loop local ollama filesystem" \ --loop-name "ctx capability selection" \ --permissions skills,agents,mcps,harnesses \ --own-llm \ --model-provider ollama \ --model ollama/llama3.1 \ --selected local-ollama-file-operations \ --rejected legacy-reviewer \ --top-k 2 ``` The same call can read a real `.loop` file: ```bash python -m ctx.adapters.loopflow \ --loop-file select-capabilities.loop \ --permissions skills,agents,mcps,harnesses \ --own-llm \ --model-provider ollama \ --model ollama/llama3.1 ``` Add `--last-failure-file .loopflow/last-failure.txt` after LoopFlow has written that file. ## Example payload This excerpt is from the live adapter against the current ctx catalog. Exact recommendation names can change as the graph changes, but the contract shape is stable. ```json { "version": "ctx.loop_adapter.v1", "adapter": "loopflow", "permissions": { "skills": true, "agents": true, "mcps": true, "harnesses": true }, "loopflow": { "before_plan": "Call python -m ctx.adapters.loopflow before planning and inject this JSON as read-only context.", "use_tools": "use tools from the \"ctx\" server", "use_skills": "use skills: oocx-tfplan2md-agent-model-selection", "harness_rule": "Only load harnesses when the loop runs on a user-owned/API/local LLM." }, "mcp_server": { "name": "ctx", "command": "ctx-mcp-server", "args": [], "tools": [ "ctx__recommend_bundle", "ctx__graph_query", "ctx__recommend_related", "ctx__wiki_search", "ctx__wiki_get", "ctx__observe_dev_event", "ctx__load_entity", "ctx__mark_entity_used", "ctx__record_validation", "ctx__record_escalation", "ctx__unload_entity", "ctx__session_end", "ctx__session_state" ] }, "capabilities": { "skills": [ { "name": "oocx-tfplan2md-agent-model-selection", "type": "skill", "status": "installed", "installable": true, "load_status": "local-wiki", "source_path": "converted/oocx-tfplan2md-agent-model-selection/SKILL.md" }, { "name": "nickcrew-claude-ctx-plugin-tool-selection", "type": "skill", "status": "available", "source_catalog": "skill-index", "install_command": "ctx-skill-install nickcrew-claude-ctx-plugin-tool-selection", "installable": false, "load_status": "external-install-required", "source_path": "ctx-skill-install nickcrew-claude-ctx-plugin-tool-selection" } ], "agents": [ {"name": "oss-investigator-local-git-agent", "type": "agent"}, {"name": "loop-operator", "type": "agent"} ], "mcps": [ {"name": "local-ollama-file-operations", "type": "mcp-server"}, {"name": "multi-model-advisor-ollama", "type": "mcp-server"} ], "harnesses": [ {"name": "autogen", "type": "harness", "fit_score": 1.0}, {"name": "langfuse", "type": "harness", "fit_score": 1.0} ] }, "related_recommendations": [ { "id": "mcp-server:ollama", "name": "ollama", "type": "mcp-server", "tldr": "mcp-server recommendation.", "reason": "related via local-ollama-file-operations; normalized score 1.000", "installable": true, "load_status": "local-wiki", "source_path": "entities/mcp-servers/ol/ollama.md", "selected": false, "selection_state": "suggested_related" } ], "agent_loop": { "before_act": "Load only the granted capability groups from capabilities.*.", "on_failure": "Pass the latest failure back as last_failure before the next plan.", "harness_install": "ctx-harness-install --dry-run '--goal=mcp agent loop local ollama filesystem' --model-provider=ollama --model=ollama/llama3.1 -- autogen" }, "warnings": [] } ``` ## How LoopFlow would consume it The smallest integration is a pre-plan hook: ```python from ctx.adapters.loopflow import recommend_for_loop ctx_payload = recommend_for_loop( goal=loop.goal, loop_name=loop.name, loop_kind="loopflow", look_at=loop.look_at, done_when=loop.done_when, last_failure=loop.last_failure_text, selected=loop.selected_ctx_ids, rejected=loop.rejected_ctx_ids, permissions={"skills", "agents", "mcps", "harnesses"}, own_llm=runner.uses_user_owned_model, model_provider=runner.model_provider, model=runner.model, ) loop.add_readonly_context("ctx", ctx_payload) if ctx_payload["mcp_server"]["command"]: runner.register_mcp_server( name=ctx_payload["mcp_server"]["name"], command=ctx_payload["mcp_server"]["command"], args=ctx_payload["mcp_server"]["args"], ) if ctx_payload["loopflow"]["use_skills"]: loop.add_planning_hint(ctx_payload["loopflow"]["use_skills"]) for row in ctx_payload["related_recommendations"]: loop.add_planning_hint(f"consider related ctx recommendation: {row['id']}") ``` After a failed observe step, LoopFlow passes the new failure text back into the next adapter call. That is the agent-loop back edge: LoopFlow keeps the retry logic, and ctx refreshes recommendations based on what just failed. ## Permission model The adapter fails closed: - `--permissions skills` only returns skill recommendations. - Goals that imply local files, `feature_implementation`, no API keys, or a clear programming language overfetch and then hide non-local, credentialed, generic-planning, or wrong-language capability and related rows. - `--permissions mcps` returns MCP server recommendations and exposes only read-only ctx MCP tools: recommendation, graph query, and wiki lookup. - Lifecycle MCP tools such as load, mark-used, validation, escalation, unload, and session tools are exposed only when all capability groups are granted: `skills`, `agents`, `mcps`, and `harnesses`. - `--permissions harnesses` returns no harnesses unless `--own-llm` is present. `--model-provider` and `--model` improve ranking and dry-run command metadata; they are not user-owned model consent. - `agent_loop.harness_install` is always a `--dry-run` command. It shows what would be installed; it does not mutate the host. `.loop` files can request ctx grants with one small line: ```loop ctx grants: skills, mcps, harnesses ``` CLI/API grants take precedence. If the command passes `--permissions`, those grants replace the `.loop` line. If the API caller passes `permissions=...`, that explicit set is authoritative. If neither is present, the `.loop` grants are used; if none are present anywhere, the adapter returns no capabilities. This lets a LoopFlow user decide whether a loop may use skills, agents, MCPs, or harnesses without giving ctx authority to bypass the loop's own gates. ## Owner ask The integration proposal for LoopFlow is intentionally small: 1. Add an optional `ctx` pre-plan hook in the LoopFlow runner. 2. Let `.loop` users grant capability groups: `skills`, `agents`, `mcps`, and `harnesses`. 3. Inject the returned JSON as read-only context before planning. 4. Register the ctx MCP server only when the adapter returns an MCP command. 5. Surface `agent_loop.harness_install` as an explicit user action, not an automatic install. That gives LoopFlow the ctx graph, llm-wiki, MCP server, skill recommender, and user-owned model harness recommendations while preserving LoopFlow's language, human gates, and `done when` verification model.