<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Prometheus AGS - Medium]]></title>
        <description><![CDATA[Prometheus Agentic Growth Solutions - Medium]]></description>
        <link>https://medium.com/prometheus-ags?source=rss----eb4aa58f462b---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Prometheus AGS - Medium</title>
            <link>https://medium.com/prometheus-ags?source=rss----eb4aa58f462b---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 06:34:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/prometheus-ags" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Stop Prompting. Start Designing Loops.]]></title>
            <link>https://medium.com/prometheus-ags/stop-prompting-start-designing-loops-5216138e23b3?source=rss----eb4aa58f462b---4</link>
            <guid isPermaLink="false">https://medium.com/p/5216138e23b3</guid>
            <category><![CDATA[skills]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[loop]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Travis James]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 21:51:45 GMT</pubDate>
            <atom:updated>2026-06-24T21:57:26.532Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>How the prometheus-skill-pack turns Claude Code’s `/loop` construct — and every other AI coding agent — into a self-improving autonomous system</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*745SdcJEeDP4bNoAZijaKw.png" /><figcaption>Agents and Loops</figcaption></figure><p><em>[Travis James — human-authored framing]</em></p><p>Boris Cherny said it plainly at Acquired Unplugged on June 2, 2026. He was sitting across from Ben Gilbert and David Rosenthal of the Acquired podcast, in San Francisco, at an event hosted by WorkOS. The quote spread everywhere within 48 hours:</p><blockquote>“I don’t prompt Claude anymore. I have loops running. They’re the ones that are prompting Claude and figuring out what to do. My job is to write loops.”</blockquote><p>He wasn’t being provocative. He was reporting state. Cherny — who created Claude Code as a side project in September 2024, watched it become the tool behind close to 4% of all public GitHub commits, and now manages it as the head of the product at Anthropic — has spent eight months not writing a line of code by hand. He manages fleets of AI agents instead. Some days, a few hundred. Some days, thousands. On the big days, tens of thousands.</p><p>What Cherny described is not a Claude Code feature. It’s a design posture. The feature is the loop. The posture is treating the loop as your primary unit of work.</p><p>This article is about that posture — and specifically, about how the **prometheus-skill-pack** turns that posture into a production-grade system that works across Claude Code, OpenCode, Codex, and Kimi Code, compounds learning across sessions, and self-improves from its own output history.</p><p>The comparison matters. Claude Code’s `/loop` command alone gets you a repeating agent. The prometheus-skill-pack wired to `/loop` gets you a loop that remembers what it learned last Tuesday, knows when it’s off-track, routes questions to the right MCP server, and proposes updates to its own skills when it discovers a better way to do something.</p><p>Those are not the same thing.</p><h3>Part I: What a Loop Actually Is</h3><p><em>[Travis James ← AI — strategic framing, AI-drafted, Travis-edited for precision]</em></p><p>Addy Osmani — engineering lead at Google Chrome — gave the movement its name in June 2026. He called it <strong>loop engineering</strong>: the practice of designing the system that prompts an AI agent on a schedule, instead of typing each prompt yourself. Osmani synthesized the core idea from Cherny’s Acquired Unplugged statement and work by Peter Steinberger, and named six building blocks of a well-engineered loop: automations, worktrees, skills, connectors, sub-agents, and memory.</p><p>The six-block definition is useful. But Cherny’s framing is more fundamental: a loop is the <em>layer above prompting</em> in the abstraction hierarchy. The autonomy ladder runs like this:</p><blockquote>Level 0 — Manual prompt: You type. The model responds. You type again.<br>Level 1 — Tool use: The model calls tools. You approve or observe.<br>Level 2 — Agentic: The model chains tool calls across a task. You watch.<br>Level 3 — Loop: The loop prompts the model. The model works. The loop checks.<br>Level 4 — Self-improving: The loop writes to memory. Next time, it knows what it learned.</blockquote><p>Most teams in 2026 are at Level 2. They call it “agentic coding” and are impressed that Claude Code can run tests and fix its own errors. What Cherny is doing — what the prometheus-skill-pack is designed to do — is Level 3 bleeding into Level 4.</p><p>Level 3 is structural, not cosmetic. The difference between prompting an agent and running a loop is the difference between throwing a ball and designing a machine that throws balls on a schedule while you do something else. The output can look similar. The architecture is not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R6vqgZEFYvNPouEznk6rKQ.png" /><figcaption>Loop cycle</figcaption></figure><p><em>[AI verbatim — diagram]</em></p><p>The loop has three structural requirements: a <strong>trigger</strong> (when does it fire?), a <strong>termination condition</strong> (how does it know when to stop?), and a <strong>feedback source</strong> (how does it evaluate progress?). Everything else — the skill, the sandboxing, the MCP servers, the memory — is about making each of those three components more accurate.</p><p>That is what the prometheus-skill-pack is for.</p><h3>Part II: Claude Code’s Native Loop Primitives</h3><p><em>[Travis James ← AI — technical documentation, AI-drafted, Travis-edited for accuracy]</em></p><p>Claude Code ships four native loop primitives in its current release. Understanding each is a prerequisite for understanding what the skill-pack extends and why.</p><h4>`/loop` — Repeating agent on interval</h4><p>The basic construct. You provide a prompt; `/loop` fires it repeatedly at a configured interval. No goal checking. No memory. No self-evaluation. It runs until you stop it or until an error terminates the agent.</p><pre>/loop &quot;Run the test suite and fix any failures you find&quot;</pre><p>The trade-off is structural: without a termination condition, the loop doesn’t know when it’s done. It will keep firing the same prompt even after the goal is met, burning tokens and potentially introducing regressions. The loop itself isn’t intelligent — it’s a timer.</p><h4>`/goal` — Goal-conditioned termination (added v2.1.139, May 2026)</h4><p>This is the mechanism that separates a repeating prompt from a real loop. When you set a goal, Claude Code uses a <em>separate, faster model</em> — not the same model that wrote the code — to check whether the termination condition is met after each turn.</p><pre>/goal &quot;All tests in tests/auth pass and ESLint reports zero errors&quot;</pre><p>The separation is critical. The model that wrote the code has an obvious structural bias toward believing the code is done. The goal-checking model receives only the artifact and the condition, not the generation history. This is the Claude Code implementation of what the prometheus-skill-pack calls the <strong>anti-sycophancy gate</strong> — critic context isolation as a structural property of the loop.</p><h4>`/schedule` — Cron-style loop scheduling</h4><p>Fire a loop on a calendar schedule rather than a continuous interval. Useful for maintenance tasks, daily context enrichment, and periodic audit loops.</p><pre>/schedule &quot;0 4 * * *&quot; &quot;Review all open issues and triage by severity&quot;</pre><h4>`/workflows` — Multi-agent orchestration dashboard</h4><p><strong>Agent View:</strong> the fleet dashboard. All running sessions visible in one place. Background sessions run in isolated git worktrees, so parallel agents can’t overwrite each other’s changes.</p><p>The worktree isolation is not a convenience feature. It’s what makes parallel agents viable. Without worktree isolation, two agents running in the same repository will eventually produce a merge conflict that neither can resolve. With worktrees, each agent owns its own checkout and the tree cleans itself up when the agent finishes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BC_VoHzL9uD2NxdEILghLw.png" /><figcaption>Operator running a loop</figcaption></figure><p><em>[AI verbatim — sequence diagram]</em></p><p>These four primitives are real and they’re useful. The honest assessment of their limits: they don’t persist learning across sessions, they don’t have a semantic knowledge base to draw on at loop start, they don’t self-correct for sycophancy in their reflection output, and they don’t propose updates to their own skill definitions when they discover better approaches.</p><p>That’s the gap. That’s what the skill-pack closes.</p><h3>Part II-B: The Methodology Behind the Loop — KBD, PMPO, and Metaprompting</h3><p><em>[Travis James — authored, original methodology explanation]</em></p><p>Before describing how the loop architecture works, the terminology needs grounding. KBD and PMPO are Prometheus AGS methodologies. They are not industry-standard terms. Using them without explanation is the kind of assumption that makes articles useful only to insiders.</p><h4>What is Metaprompting?</h4><p>Metaprompting is the practice of designing a system of prompts — rather than writing a single prompt — to produce more reliable, bounded, and evaluable agent behavior. Where a prompt tells a model what to do once, a metaprompt defines the routing, critique, cross-checking, and evaluation logic that governs <em>how the model is prompted over time</em>.</p><p>The distinction matters at scale. A single well-crafted prompt degrades as tasks grow complex: the model accumulates context drift, conflates phases, and eventually produces output that satisfies the surface request while missing the structural intent. A metaprompting system prevents that by separating the task (what to produce) from the orchestration (when to produce it, who checks it, and what happens when it fails).</p><p>Claude Code’s `/goal` command — where a *separate model* checks completion rather than the model that did the work — is a metaprompting primitive. The goal-checker is a meta-level prompt governing the primary agent.</p><h4>What is PMPO?</h4><p><strong>PMPO</strong> — <strong>Prometheus Meta-Prompting Orchestration</strong> — is the Prometheus AGS metaprompting methodology. It defines a two-loop cognitive architecture for agent-driven software development:</p><pre>Inner loop (Task loop):     Spec → Plan → Execute → Reflect<br>Outer loop (Evolution loop): Compile → Evaluate → Optimize → Promote</pre><p>The inner loop governs a single development task. The outer loop governs the evolution of the methodology itself: it compiles what the inner loop produced, evaluates it against goals, optimizes the approach, and promotes lessons into the durable knowledge base.</p><p>PMPO’s core architectural claim is that **phase discipline is the immune system of the recursive loop**. An agent allowed to reflect while still in Execute mode will self-validate rather than surface deltas. An agent allowed to plan while still in Assess mode will anchor on un-stress-tested assumptions. The hard phase boundaries are not procedural formality — they are the structural mechanism that prevents the loop from collapsing into a single-pass execution model dressed up as iteration.</p><p>The sycophancy-correction MCP server enforces this structurally: the Reflect phase output is checked for sycophantic patterns before it’s logged, because a reflection that leads with what worked is not a reflection — it’s a summary. Summaries don’t improve loops. Deltas do.</p><h4>What is KBD?</h4><p><strong>KBD</strong> — <strong>Knowledge-Based Developmen</strong>t — is the Prometheus AGS methodology for keeping domain knowledge and implementation in continuous alignment. It addresses the translation loss problem: the gap between what a domain expert knows, what an AI agent understands, and what the code actually does.</p><p>KBD’s three mechanisms:</p><p>1. <strong>Knowledge base as session substrate</strong> — Every development session starts with KB context priming (`pk-focus-on-prompt.sh`) and ends with KB enrichment. The agent never starts from zero.</p><p>2. <strong>Phase discipline via KBD skills </strong>— The six KBD skills (`/kbd-assess`, `/kbd-analyze`, `/kbd-plan`, `/kbd-execute`, `/kbd-reflect`, `/kbd-evolve`) enforce hard phase boundaries. Each phase produces a specific artifact and a handoff to the next phase. No cross-phase contamination.</p><p>3. <strong>Waypoint continuity</strong> — The `.kbd-orchestrator/position-reminder.txt` protocol ensures that when a context window ends and a new session starts, the agent reads its exact position before doing anything else. The loop doesn’t lose its place.</p><p>KBD is what you use when the work spans multiple sessions, multiple phases, and multiple agents. It’s the structure that prevents “we ran a bunch of agents at this repository” from becoming “we don’t know what state we left it in.”</p><h4>What is the iterative-evolver?</h4><p>The `iterative-evolver` skill is the outer loop of PMPO made executable. It manages the evolution cycle — reading what the inner loop (KBD) produced, evaluating it against goals, and deciding what to optimize next. The evolver bridge (`evolver-bridge.json`) connects KBD phase completions to evolution items: when a KBD phase finishes, the bridge tells the evolver which evolution goals that completion satisfied.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LSyZb2MCKUpxOH7aQSTEuQ.png" /><figcaption>Iterative Evolver lifecycle</figcaption></figure><p><em>[AI verbatim — diagram]</em></p><p>The relationship between KBD and iterative-evolver is hierarchical: KBD executes; the evolver decides what to execute next. PMPO is the methodology that governs both. The prometheus-skill-pack implements all three as executable skills.</p><p>This is what distinguishes the prometheus-skill-pack’s loop architecture from a collection of scripts. The scripts implement the methodology. The methodology is what makes the loop compound rather than merely repeat.</p><h3>Part III: The prometheus-skill-pack Loop Architecture</h3><p><em>[Travis James — authored framing, original strategic analysis]</em></p><p>The prometheus-skill-pack’s loop architecture operates at three layers simultaneously. Understanding which layer does what is important because the failure mode of all loop systems is layer-blending: using a L1 construct for a L3 responsibility and wondering why the system doesn’t compound over time.</p><h4>L1: The KBD Inner Loop (Change Execution)</h4><p>The Knowledge-Based Development loop handles single-phase execution. Each turn through the loop is one KBD phase: assess → analyze → plan → execute → reflect. The loop runs inside a session. It terminates when the phase is complete. Its output feeds into the layer above.</p><p>The KBD phases are hard-bounded. This matters structurally. A plan produced during assess is contaminated by un-stress-tested assumptions. A reflect that leads with what worked rather than what diverged is sycophantic by structure. The KBD phase sequence exists to prevent both.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*maW2J8Dbq5-IzhPYJKFMNA.png" /><figcaption>KBD Inner Loop</figcaption></figure><p><em>[AI verbatim — diagram]</em></p><p>Child KBD skills are invoked by name from within a parent skill execution. This is the <strong>nested loop</strong> pattern: the parent loop manages phase transitions; child loops handle individual changes within a phase.</p><pre># Parent: executing the self-learning-loop-integration phase<br>/kbd-execute self-learning-loop-integration<br><br># Inside that, the executor spawns child skill invocations per change:<br># Starting change 3 of 10: change-slli-003<br>/kbd-execute handles change-slli-003 via its own sub-loop<br># Completed change 3 of 10: change-slli-003</pre><p>The progress signal is not optional. Every turn emits:</p><pre>Starting kbd-execute — self-learning-loop-integration (step 3 of 10)<br>Starting change 3 of 10: change-slli-003<br>Completed change 3 of 10: change-slli-003<br>Completed kbd-execute — self-learning-loop-integration (step 3 of 10)</pre><p>This is not ceremony. It’s the invariant that makes long multi-session work debuggable. When a context window ends and the next session starts, the position-reminder protocol — first tool call reads `.kbd-orchestrator/position-reminder.txt` — restores exact position without requiring the operator to reconstruct state from the transcript.</p><h4>L2: The pmpo-outer-loop (Goal Coordination)</h4><p>The outer loop manages goal-level coherence across multiple KBD phases. This is what the prometheus-skill-pack calls the <strong>L3 loop</strong> (following Cherny’s level hierarchy), activated via `/loop-define`, `/loop-tick`, and `/loop-report`.</p><pre># Define a loop with goal, feedback sources, and termination<br>/loop-define --name &quot;continuous-quality&quot; \<br>  --goal &quot;All failing tests resolved and no HIGH/CRITICAL sycophancy patterns in reflect output&quot; \<br>  --feedback-source &quot;command:npm test&quot; \<br>  --feedback-source &quot;command:sycophancy-check-reflection.sh&quot; \<br>  --termination &quot;condition:all_feedback_green&quot; \<br>  --escalation &quot;threshold:3_consecutive_failures&quot; \<br>  --cadence &quot;interval:30m&quot;<br><br># Tick the loop — evaluate feedback sources, emit continue/escalate/terminate<br>/loop-tick continuous-quality<br><br># Report current loop state<br>/loop-report continuous-quality</pre><p>The `loop-tick.sh` runner evaluates each feedback source and exits with three possible codes: `0` = continue, `1` = escalate to operator, `2` = terminate successfully. This is what separates a loop from a while-true. The exit code is a contract: the loop doesn’t decide it’s done, the feedback source decides it’s done.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2ZR5daTUTSItk0HgggFULw.png" /><figcaption>Loop Ticks</figcaption></figure><p><em>[AI verbatim — diagram]</em></p><h4>L3: The iterative-evolver (Self-Improvement)</h4><p>The evolver loop operates above the outer loop. It doesn’t manage individual phases or goals — it manages the evolution of the methodology itself. The bridge between inner and outer loop is `evolver-bridge.json`, which maps KBD phase completions to evolver evolution items, enabling the evolver to know which improvements landed.</p><p>The self-improvement loop is where the system stops being a tool and starts being a substrate. When `evaluate-session.sh` writes session learning to `~/.prometheus/learning-log/`, when `propose-skill-update.sh` detects a pattern that matches an installed skill and files a candidate update, and when `pmpo-skill-creator — update &lt;skill-name&gt;` presents that candidate to the operator for human-gated approval — that sequence is the skill-pack teaching itself.</p><p>The human gate is load-bearing. Auto-applying skill updates without operator review is structurally sycophantic: the system updates its own instructions based on its own judgment of what worked, without adversarial review. The gate breaks that loop.</p><h4>Part IV: The MCP Server Substrate</h4><p><em>[Travis James ← AI — technical specification, AI-drafted, Travis-edited for accuracy]</em></p><p>The eight MCP servers installed by the prometheus-skill-pack are not tools bolted on to the loop. They are the connective tissue that makes the loop coherent across sessions, across tools, and across time. Each runs as a persistent service — the HTTP-based ones as macOS launchd agents, the stdio-based ones on-demand via the MCP client. All are addressable by any AI tool configured to reach them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xeGZw5cVe5dOdW8Xn31LIw.png" /><figcaption>MCP Servers in the Prometheus Skill System</figcaption></figure><p><em>[AI verbatim — table]</em></p><h4>Firecrawl vs Tavily: Not Interchangeable</h4><p>Both Firecrawl and Tavily provide web access inside loops, but they solve different parts of the problem. Using them interchangeably produces the wrong tool for each job.</p><p><strong>Tavily</strong> is search-first. The `tavily_search` tool fans out to multiple sources, ranks results, and returns structured summaries. It integrates natively with Amazon Bedrock AgentCore, Azure, IBM watsonx, and Snowflake. For loops that need to know *what exists* on a topic — issue research, technology scouting, competitive landscape — Tavily is the right reach. The trade-off: it returns summaries, not full page content, and deep extraction requires separate calls.</p><p><strong>Firecrawl</strong> is extraction-first. The full workflow — Find → Extract → Clean → Use — runs in a single API. Its 13 MCP tools cover `firecrawl_scrape`, `firecrawl_crawl`, `firecrawl_map`, `firecrawl_extract` (structured extraction using LLM-backed parsing), `firecrawl_search`, and `firecrawl_interact` (click, scroll, form submission). For loops that need to pull full page content, parse PDFs, or interact with dynamic web UIs, Firecrawl is the correct substrate.</p><p>The architecture decision: <strong>Tavily for discovery, Firecrawl for extraction</strong>. A loop that needs to find relevant pages and then extract structured data from those pages uses both in sequence. A loop that only needs to know what exists uses Tavily alone.</p><p><strong>Self-hosting.</strong> Firecrawl’s engine is AGPL-3.0 and runs as a Docker service. At Prometheus AGS, we self-host the Firecrawl stack — the MCP server connects to our local instance at port 8948 rather than the Firecrawl cloud API. This means web data never transits a third-party service. For loops operating against internal documentation, private repositories, or air-gapped environments, self-hosting is the only viable option. Tavily has no self-hosted option.</p><pre># Firecrawl self-hosted at Prometheus AGS — loop searches and extracts without external API dependency<br>FIRECRAWL_API_URL=http://localhost:3002  # local Firecrawl Docker instance<br><br># Example: loop that discovers API docs pages and extracts structured endpoint data<br>firecrawl_search(&quot;authentication endpoints site:docs.internal.example.com&quot;)<br># → Returns ranked pages with full content (not just summaries)<br>firecrawl_extract(url, schema={&quot;endpoints&quot;: [...], &quot;auth_methods&quot;: [...]})<br># → Returns structured JSON from full page, no additional call needed</pre><p><em>[AI verbatim — code sample]</em></p><p>The install sequence puts all eight into production as persistent background services:</p><pre># Install and start all 7 MCP servers as launchd agents<br>bash scripts/install-mcp-services.sh<br><br># Configure all 8 across all 7 supported AI tools (Claude Code, OpenCode, Codex, Kimi, MiniMax, Cursor, Windsurf)<br>bash scripts/configure-mcp-all-tools.sh<br><br># Check service health<br>bash scripts/check-mcp-health.sh</pre><p><em>[AI verbatim — code sample]</em></p><p>The cross-tool configuration is what makes the loop architecture tool-agnostic. When OpenCode or Codex is running the loop instead of Claude Code, it connects to the same surreal-memory server at port 23001, reads the same KB context, writes the same session summaries. The substrate is shared even when the agent client changes.</p><h4>The context priming flow</h4><p>Every loop turn starts with `pk-focus-on-prompt.sh`. It runs a hybrid lexical and semantic search against the knowledge base — combining keyword matching with a `POST /api/v1/memory/search` to surreal-memory — and returns a prioritized context block that the agent receives before it starts work. This is the mechanism that makes each loop turn incrementally smarter than the last: the loop doesn’t just repeat, it arrives at each turn better-informed than it was at the previous one.</p><pre># What runs at loop start (automatic via SubagentStart hook)<br>pk-focus-on-prompt.sh &quot;generate the authentication module&quot;<br># Returns: ranked KB context relevant to auth patterns, prior session notes,<br>#          any surreal-memory entries tagged with auth topics</pre><p><em>[AI verbatim — code sample]</em></p><h4>The sycophancy gate</h4><p>The reflector SubagentStop hook runs `sycophancy-check-reflection.sh` before any reflection output is logged. The check invokes the sycophancy-correction MCP server at configurable strictness levels.</p><p>A good reflection must lead with delta — what diverged from plan — then root cause, then corrective actions. A reflection that leads with what worked, summarizes success without surfacing gaps, or validates the agent’s own prior decisions is structurally sycophantic: it makes the loop believe it did better than it did, which corrupts the next iteration’s planning assumptions.</p><p>The gate enforces the structural requirement. Two consecutive rejections produce a warning; a third attempt is accepted regardless. This bounds the loop against infinite reflection cycles while maintaining meaningful quality pressure on the first two.</p><h3>Part V: Loops Across Every Tool — Claude Code, OpenCode, Codex, Kimi</h3><p><em>[Travis James — authored analysis, comparative framing]</em></p><p>The prometheus-skill-pack installs to seven AI tools simultaneously. The loop architecture runs on all of them. But the tools have genuinely different properties that affect how you’d deploy the architecture, and flattening those differences produces bad loop design.</p><p>This isn’t “Claude Code is best” — that framing misses the point. The relevant question is: which tool has the structural properties that match the loop’s requirements? The answer depends on the loop, not on tribal loyalty.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RsAfCFFROlSDf1i2n4s00w.png" /><figcaption>Skill Pack Use</figcaption></figure><p><em>[AI verbatim — diagram]</em></p><p><strong>Claude Code</strong> is where the loop primitives are most developed. `/loop`, `/goal`, `/schedule`, `/workflows`, and Agent View all ship first-party. The worktree isolation via `isolation: “worktree”` in the Agent tool options is built-in. For any loop where you want native first-party primitives and worktree sandboxing without configuration overhead, Claude Code is the correct substrate.</p><p><strong>OpenCode</strong> is the open-source terminal agent. It supports MCP configuration and runs the same shared substrate — the seven servers are configured into `~/.opencode/mcp.json` by `configure-mcp-all-tools.sh`. The trade-off: loop primitives require manual scripting or shell wrappers rather than first-party slash commands. The advantage: model-agnostic, no vendor lock, and the OpenCode Zen gateway gives access to 30+ models including free-tier options.</p><p><strong>OpenAI Codex</strong> supports kernel-level sandboxing — the strongest isolation primitive in the group. For loops that need to execute arbitrary code with no risk of host system side effects, Codex’s sandboxing model is architecturally superior. The prometheus-skill-pack configures Codex MCP connectivity at `~/.codex/skills/` and `~/.codex/mcp.json`, but loop orchestration must be driven externally via the shared shell scripts.</p><p><strong>Kimi Code </strong>(Moonshot AI) is not the newcomer anymore — it’s the serious contender. Two models matter here, and they serve different purposes within the loop.</p><p><strong>Kimi K2.6</strong> is the general-purpose agentic model: 1T total parameters, 32B activated per token via MoE architecture, 256K context window, and native multimodal input (text, image, video). It runs in both thinking and non-thinking modes — non-thinking for fast tool calls inside tight loop iterations, thinking mode for multi-step planning at loop initialization. K2.6 handles the long-horizon execution and agent swarm coordination that most agentic loops need. It’s the default model for Kimi Code’s terminal client when K2.7 Code is not available.</p><p><strong>Kimi K2.7 Code</strong> (released June 12, 2026) is the coding-specific refinement of K2.6. Same MoE architecture — 1T parameters, 32B activated, 384 experts with 8 selected per token — but the weights and training were specialized for coding tasks with forced thinking mode enabled by default. The benchmark deltas over K2.6 are specific: +21.8% on Kimi Code Bench v2, +11.0% on Program Bench, +31.5% on MLS Bench Lite. Thinking token usage is 30% lower than K2.6 despite more reliable long-context instruction following. In agentic terms: higher end-to-end task success rates on complex software engineering workflows, with less token burn per completed task. That combination — better accuracy, lower cost per token, lower reasoning overhead — makes K2.7 Code the right model for loops that run unattended over multi-file codebases.</p><p><strong>The Kimi Code CLI</strong> is the surface that connects K2.7 Code to the loop pattern. It’s not just a prompt interface — it’s an agentic planning engine. When you give Kimi Code a task, it generates a **coding plan** first: a multi-step decomposition of what files need to change, in what order, with what validation checkpoints. That plan is inspectable before execution. The agent then executes against the plan, runs the validation steps (tests, linting, type checking), and iterates on failures autonomously. Session persistence is built in — ` — continue` resumes any prior session, and ` — session &lt;id&gt;` switches between projects.</p><pre># Kimi Code CLI: agentic loop with coding plan<br>kimi-code &quot;Refactor all API handlers to use the new auth middleware&quot;<br><br># Kimi Code generates and shows plan before execution:<br># Plan:<br>#   1. Identify all handlers in src/handlers/ (12 files)<br>#   2. Add middleware import to each handler<br>#   3. Wrap route definitions with auth middleware<br>#   4. Run test suite: npm test<br>#   5. Fix any failures before marking complete<br><br># With thinking mode enabled (K2.7 Code default):<br>kimi-code --model kimi-k2-7-code --think &quot;Add rate limiting to all public endpoints&quot;</pre><p><em>[AI verbatim — code sample]</em></p><p>The Kimi advantage in the loop context: K2.7 Code’s instruction-following reliability in long contexts directly addresses the most common loop failure mode — the agent that drifts from the original intent across many tool call turns. A model that follows multi-step plans more reliably and produces fewer thinking tokens per step is architecturally better suited to unattended loop execution than a general-purpose model running with thinking disabled.</p><p>The prometheus-skill-pack installs skills at `~/.kimi-code/skills/` and configures all 8 MCP servers (including firecrawl) at `~/.kimi-code/config.toml`. Loop orchestration requires shell wrappers rather than first-party slash commands, but the shared substrate — surreal-memory at port 23001, prometheus-knowledge at port 8942 — is identical to Claude Code.</p><h4>Sandboxing in autonomous loops</h4><p>The structural issue with fully autonomous loops is blast radius. An agent that runs unattended can delete files, push broken code, or accumulate technical debt faster than human review can catch it. The sandboxing options, from weakest to strongest:</p><pre>Git worktree → Filesystem → Process → Kernel-level sandbox</pre><p><strong>Worktree isolation</strong> (Claude Code native, available via prometheus-skill-pack on all tools): each agent run gets its own git checkout. Changes are sequestered until the agent finishes; the tree is deleted if no changes land. This is the default recommendation for most loops.</p><p><strong>Filesystem isolation</strong> (available via Docker wrapping on any tool): the agent can only touch the mounted directory. Stronger than worktrees for loops that run shell commands with broad filesystem access.</p><p><strong>Kernel-level sandboxing </strong>(Codex native): syscall filtering prevents the agent from touching anything outside the declared scope. The strongest isolation. The right choice for any loop executing untrusted or dynamically generated code.</p><p>For the prometheus-skill-pack’s own loops, worktree isolation is the default. For loops that execute test suites against external infrastructure or run arbitrary shell scripts, the recommendation is to wrap in Docker or use Codex’s native sandboxing.</p><h3>Part VI: Karpathy-Pattern Learning and Cross-Session Memory</h3><p><em>[Travis James — authored, original strategic analysis]</em></p><p>Andrej Karpathy’s flat-file knowledge base pattern — canonical text files organized by topic, ingested on session start, updated on session end — is the epistemic substrate of the prometheus-skill-pack. The knowledge base is not a database of facts. It’s a growing substrate of what the system has learned about how to work.</p><p>The memory architecture has three layers:</p><p><strong>Layer 1 — File-based KB (prometheus-knowledge)</strong>: The Karpathy-pattern flat-file KB. Human-readable, version-controlled, queryable by `pk-focus-on-prompt.sh`. This is the primary substrate for context priming. Every session that produces a learning worth keeping writes to it via `pk ingest`.</p><p><strong>Layer 2 — Graph memory (surreal-memory)</strong>: The semantic knowledge graph. SurrealDB with HNSW vector indexing. Writes via `POST /api/v1/memory` (plain REST — available to any shell script, not just MCP clients). Reads via `POST /api/v1/memory/search`. The graph stores relationships between concepts, not just facts. `create_entity`, `create_relation`, `semantic_search` — the graph traversal tools enable the loop to reason about what it knows, not just retrieve it.</p><p><strong>Layer 3 — Learning log (`~/.prometheus/learning-log/`)</strong>: Session-level JSONL files written by `evaluate-session.sh` at SubagentStop[executor] time. Each entry records what the session did, what it learned, and what it would do differently. `propose-skill-update.sh` reads these entries and identifies patterns that match installed skills, filing candidates to `~/.prometheus/skill-updates/pending.log`.</p><p>The write-back sequence on session end:</p><pre># 1. write-session-summary.sh runs FIRST (Stop hook ordering is a correctness constraint)<br>write-session-summary.sh → ~/.prometheus/last-session-summary.txt<br><br># 2. forge-reflect-on-stop.sh reads the summary and writes to forge + KB<br>forge-reflect-on-stop.sh → forge ingest + pk ingest &lt; last-session-summary.txt<br><br># 3. evaluate-session.sh writes structured learning<br>evaluate-session.sh → ~/.prometheus/learning-log/&lt;date&gt;.jsonl + surreal-memory REST<br><br># 4. propose-skill-update.sh scans learning log for skill patterns<br>propose-skill-update.sh → ~/.prometheus/skill-updates/pending.log</pre><p><em>[AI verbatim — code sample]</em></p><p>The periodic nudge runs every four hours as a launchd agent (`prometheus-nudge.plist`). It invokes the knowledge base independently of any active session — ensuring that what was learned in the morning session is available to the afternoon session even if the operator didn’t manually trigger enrichment.</p><h4>How accumulated learning changes current output</h4><p>This is the structural question that separates “loop engineering” from “loop marketing.” Here’s the concrete mechanism:</p><p>1. Session N runs the auth module loop. Tests fail. The agent fixes them. The session summary notes that the failure was caused by a missing mock for the Redis client in the test environment.</p><p>2. `evaluate-session.sh` writes this to the learning log with a tag referencing the auth module.</p><p>3. `propose-skill-update.sh` detects that the pattern — “Redis mock missing in test setup” — appears in the auth-related KB entries and matches the `testing` skill’s known failure modes. A candidate update is filed.</p><p>4. In session N+1, `pk-focus-on-prompt.sh` retrieves the learning log entry for the auth module as part of context priming.</p><p>5. The agent starts session N+1 already knowing about the Redis mock issue. It doesn’t reproduce the same failure.</p><p>6. The operator reviews the pending skill update and approves it with `pmpo-skill-creator — update testing`. The `testing` skill now includes Redis mock setup as a first-class step.</p><p>7. In session N+2 on a different repository with a different operator, the `testing` skill carries the Redis mock learning. The failure doesn’t happen there either.</p><p>That’s what cross-session learning compounding looks like at the structural level. Not magic. Not emergent. Engineered.</p><h3>Part VII: Making It Fully Autonomous</h3><p><em>[Travis James — authored, strategic analysis]</em></p><p>Full autonomy is a spectrum. The question isn’t “is this autonomous?” — it’s “at which decision points does the system require human input, and are those the right ones?”</p><p>The prometheus-skill-pack takes a specific position: the loop should be autonomous at the execution layer and human-gated at the architecture layer. Agents should execute without interruption; operators should approve changes to the system that governs those agents.</p><p>The five decision points where human gates are appropriate:</p><p><strong>1. Loop definition.</strong> The operator writes `loop.json`. What the loop tries to do, what counts as done, and what triggers escalation are human decisions. The system executes; the operator decides the contract.</p><p><strong>2. Skill updates. </strong>`propose-skill-update.sh` files candidates. `pmpo-skill-creator — update` presents them. The operator approves or rejects. Auto-applying skill updates is a structural sycophancy risk: the system modifying its own instructions based on its own evaluation of its own output.</p><p><strong>3. Escalation handling.</strong> When `loop-tick.sh` exits 1 — escalation threshold exceeded — the loop stops and notifies. The operator decides whether to resume, adjust the loop definition, or abandon the task. This is not a limitation. It’s the correct division of cognitive labor.</p><p><strong>4. Phase boundaries (for KBD inner loop).</strong> The KBD phases are hard-bounded. Agents don’t cross phase boundaries autonomously. The position-reminder protocol ensures the operator can resume from any boundary without reconstructing state.</p><p><strong>5. KB promotion.</strong> Learning written to the learning log becomes KB-promoted only when the operator reviews and confirms. The KB is the substrate for all future loops; contaminated KB corrupts future loops. The promotion gate prevents that.</p><p>Everything else — execution within a phase, test fixing, error recovery, context priming, reflection writing, session summary generation, periodic nudge — runs autonomously.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mpJYJrOnEyKjNxBk0y2wZg.png" /><figcaption>Autonomous Loop Execution</figcaption></figure><h3>Part VIII: Claude Code `/loop` Alone vs `/loop` + prometheus-skill-pack</h3><p><em>[Travis James — authored, comparative scorecard]</em></p><p>The comparison Cherny’s quote implicitly sets up: what does the loop do before the skill-pack, and what does it do after?</p><p>The honest answer is that Claude Code’s native loop primitives are a genuine advance over manual prompting. `/goal` with a separate validator model is architecturally correct. Worktree isolation is the right sandboxing default. Agent View is a real fleet management interface.</p><p>The trade-off: they don’t compound. Each loop run starts from the same baseline. What the agent learned on Monday isn’t available on Wednesday. The reflection at session end is evaluated by the same model that produced the output being reflected upon — which is structurally sycophantic by design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bug1CljLWE40zMwUhVeRHA.png" /><figcaption>Loops with and without the skill pack</figcaption></figure><p><em>[AI verbatim — table]</em></p><p>The structural difference is compounding. Claude Code’s native loop runs at constant capability. The prometheus-skill-pack loop runs at increasing capability: each session writes to memory, each memory enriches the next session’s context, each skill update makes the next loop turn more accurate.</p><p>That’s not a feature differential. It’s an architectural choice about what the loop is for.</p><h3>Part IX: Getting Started</h3><p><em>[Travis James ← AI — instructions, AI-drafted, Travis-reviewed for accuracy]</em></p><p><strong>Repository:</strong> <a href="https://github.com/Prometheus-AGS/prometheus-skill-system">https://github.com/Prometheus-AGS/prometheus-skill-system</a></p><p>The prometheus-skill-pack install sequence is documented in the repository. The short version:</p><pre># Clone and install to all detected platforms<br>git clone https://github.com/Prometheus-AGS/prometheus-skill-system<br>cd prometheus-skill-system<br><br># Install skills to all supported AI tools<br>bash scripts/install-skills-flat.sh<br><br># Install and start the 7 MCP servers as launchd agents (macOS)<br>bash scripts/install-mcp-services.sh<br><br># Configure all 7 MCP servers into all 7 AI tool configs<br>bash scripts/configure-mcp-all-tools.sh<br><br># Verify everything is running<br>bash scripts/check-mcp-health.sh</pre><p>Once installed, the canonical first loop — a continuous quality gate on the active repository:</p><pre># Define a basic quality loop<br>cat &gt; loop.json &lt;&lt; &#39;EOF&#39;<br>{<br>  &quot;name&quot;: &quot;quality-gate&quot;,<br>  &quot;goal&quot;: &quot;All tests pass and no CRITICAL/HIGH lint errors&quot;,<br>  &quot;feedback_sources&quot;: [<br>    { &quot;type&quot;: &quot;command&quot;, &quot;source&quot;: &quot;npm test&quot;, &quot;success_exit&quot;: 0 },<br>    { &quot;type&quot;: &quot;command&quot;, &quot;source&quot;: &quot;npm run lint -- --format json&quot;, &quot;success_exit&quot;: 0 }<br>  ],<br>  &quot;termination&quot;: { &quot;condition&quot;: &quot;all_feedback_green&quot; },<br>  &quot;escalation_points&quot;: [{ &quot;type&quot;: &quot;threshold&quot;, &quot;value&quot;: 3 }],<br>  &quot;cadence&quot;: { &quot;interval&quot;: &quot;30m&quot; }<br>}<br>EOF<br><br># Start the loop<br>/loop-define --from loop.json<br>/loop-tick quality-gate</pre><p><em>[AI verbatim — code sample]</em></p><p>From there, the `pkm-process-orchestrator` skill handles the full KBD lifecycle for structured development work. The nested loop pattern is automatic: the outer loop coordinates phase transitions; the inner loop executes individual changes; the child skills handle specific technical tasks within each change.</p><h3>What the Loop Is Really For</h3><p><em>[Travis James — authored, stakes close]</em></p><p>Cherny’s statement at Acquired Unplugged on June 2, 2026 wasn’t an announcement. It was a status report from someone who had already made the transition and was describing what the other side looks like.</p><p>He manages tens of thousands of agents on some days. He hasn’t written a line of code by hand in eight months. His job is to write loops.</p><p>The prometheus-skill-pack is the infrastructure that makes that posture viable for the rest of us — for teams that aren’t building Claude Code, that don’t have Anthropic’s internal toolchain, that need the loop to work across OpenCode and Codex and Kimi Code as well as Claude Code, and that need the loop to remember what it learned last week.</p><p>The loop that remembers is not just more convenient than the loop that forgets. It’s structurally different. A loop that accumulates knowledge gets better at the task it was designed to do. A loop that starts fresh every session is a very fast way to do the same thing many times.</p><p>The agents are ready. The substrate is the question. The prometheus-skill-pack is the answer to that question.</p><p><strong>Sources:</strong><br>- <a href="https://github.com/Prometheus-AGS/prometheus-skill-system">prometheus-skill-system — GitHub (Prometheus AGS)</a><br>- <a href="https://workos.com/blog/boris-cherny-claude-code-acquired-interview-takeaways">Key takeaways from Boris Cherny on building Claude Code — WorkOS</a><br>- <a href="https://www.youtube.com/watch?v=RkQQ7WEor7w">Boris Cherny: Claude Code &amp; the Future of Engineering — Acquired Unplugged (YouTube)</a><br>- <a href="https://fortune.com/2026/06/08/anthropics-boris-cherny-creator-of-claude-code-says-there-are-days-he-manages-tens-of-thousands-of-ai-agents-at-once/">Anthropic’s Boris Cherny — manages tens of thousands of AI agents at once — Fortune</a><br>- <a href="https://thenewstack.io/loop-engineering/">The Anthropic leader who built Claude Code says he ditched prompting — now he just writes loops — The New Stack</a><br>- <a href="https://addyosmani.com/blog/loop-engineering/">Loop Engineering — Addy Osmani</a><br>- <a href="https://www.theneuron.ai/explainer-articles/claude-code-creators-boris-cherny-and-cat-wu-explain-how-to-use-agent-loops/">Claude Code’s Creators Explain Agent Loops — The Neuron</a><br>- <a href="https://explainx.ai/blog/loop-engineering-coding-agents-claude-code-guide-2026">Loop Engineering: How to Design Coding Agent Loops — explainx.ai</a><br>- <a href="https://www.anthropic.com/engineering/claude-code-sandboxing">Making Claude Code more secure and autonomous with sandboxing — Anthropic</a><br>- <a href="https://www.techtimes.com/articles/318828/20260622/claude-code-loop-engineering-stop-prompting-start-designing-autonomous-agent-workflows.htm">Claude Code Loop Engineering — TechTimes</a><br>- <a href="https://medium.com/mountain-movers/what-a-loop-actually-is-boris-chernys-three-stage-definition-33dd2bfe01b3">What a Loop Actually Is: Boris Cherny’s Three-Stage Definition — Medium</a><br>- <a href="https://www.kimi.com/resources/kimi-k2-7-code">Kimi K2.7 Code: Open-Source Agentic Coding Model — Moonshot AI</a><br>- <a href="https://www.kimi.com/code">Kimi Code with K2.7 Code: Next-Gen AI Code Agent &amp; CLI — Moonshot AI</a><br>- <a href="https://www.kimi.com/ai-models/kimi-k2-6">Kimi K2.6 — Leading Open-Source Model in Coding &amp; Agent — Moonshot AI</a><br>- <a href="https://www.marktechpost.com/2026/06/12/moonshot-ai-releases-kimi-k2-7-code-a-coding-model-reporting-21-8-on-kimi-code-bench-v2-over-k2-6/">Moonshot AI releases Kimi K2.7-Code: +21.8% on Kimi Code Bench v2 — MarkTechPost</a><br>- <a href="https://blog.apify.com/firecrawl-vs-tavily/">Firecrawl vs. Tavily: 2026 guide for RAG and agent pipelines — Apify</a><br>- <a href="https://github.com/firecrawl/firecrawl">Firecrawl GitHub (AGPL-3.0, self-hostable)</a><br>- <a href="https://github.com/firecrawl/firecrawl-mcp-server">Firecrawl MCP Server — GitHub</a><br>- <a href="https://agentwiki.org/meta_prompting">Meta Prompting — Agent Wiki</a><br>- <a href="https://intuitionlabs.ai/articles/meta-prompting-llm-self-optimization">Meta-Prompting: LLMs Crafting &amp; Enhancing Their Own Prompts — IntuitionLabs</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5216138e23b3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/prometheus-ags/stop-prompting-start-designing-loops-5216138e23b3">Stop Prompting. Start Designing Loops.</a> was originally published in <a href="https://medium.com/prometheus-ags">Prometheus AGS</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>