{"id":51022761,"url":"https://github.com/cocoonstack/mindset","last_synced_at":"2026-06-21T17:01:22.969Z","repository":{"id":359376755,"uuid":"1245772981","full_name":"cocoonstack/MindSet","owner":"cocoonstack","description":"Cognitive layer above CocoonSet in the cocoonstack agent-infra design. A Mind Agent reaches Goal consensus with the user, dispatches a group of CocoonSets, and a first-class Verifier judges convergence toward the end-state. Three-tier memory (SSOT / Session-Log WAL / view) with Log-backed deterministic rollback.","archived":false,"fork":false,"pushed_at":"2026-06-05T16:01:06.000Z","size":33,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-06-05T18:29:16.998Z","etag":null,"topics":["agent","agent-infra","ai","cocoon","cocoonset","design","goal-driven","kubernetes","llm","mindset","verifier"],"latest_commit_sha":null,"homepage":null,"language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/cocoonstack.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-05-21T14:40:30.000Z","updated_at":"2026-06-05T16:01:16.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/cocoonstack/MindSet","commit_stats":null,"previous_names":["cocoonstack/mindset"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/cocoonstack/MindSet","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cocoonstack%2FMindSet","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cocoonstack%2FMindSet/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cocoonstack%2FMindSet/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cocoonstack%2FMindSet/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/cocoonstack","download_url":"https://codeload.github.com/cocoonstack/MindSet/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/cocoonstack%2FMindSet/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34618484,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-21T02:00:05.568Z","response_time":54,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["agent","agent-infra","ai","cocoon","cocoonset","design","goal-driven","kubernetes","llm","mindset","verifier"],"created_at":"2026-06-21T17:01:21.838Z","updated_at":"2026-06-21T17:01:22.948Z","avatar_url":"https://github.com/cocoonstack.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"# Next-Gen Agent Infra Design — CocoonSet \u0026 MindSet\n\n| | Today (shipped) | Tomorrow (planned) |\n|---|---|---|\n| Scheduling layer | **CocoonSet** — the `cocoonset.cocoonstack.io/v1` CRD, reconciled by `cocoon-operator`, running on `vk-cocoon` nodes | **MindSet** — the top-level cognitive layer; **not in the codebase**, it is the direction this doc defines |\n| Agent shape | `spec.agent.kind: desktop` (cloud desktop) / `autonomous` (self-driving agent) | A Mind Agent orchestrates multiple CocoonSets, converging on a Goal |\n| Convergence verdict | Operator reconciles replica count / node selection | Verifier judging \"closer to the end-state?\" |\n\n---\n\n## 1. Agent Shape: an Agent Is an Intelligent Workload\n\nAn Agent should no longer be treated as a simple \"chat box\" — it should evolve into an **intelligent Workload**. Its core characteristics:\n\n- **Form and responsibility.** An **LLM-driven self-iteration loop** is the core. Memory is realized through state management: the Agent repeatedly compares `desired state` against `observed state` until it converges on the end-state.\n- **Collaboration interface.** Driven by a **Goal (the desired end-state)**, not by a stream of fine-grained instructions.\n- **Runtime elements.** It runs inside the secure sandbox and tool set (Tools / Skills) provided by a **Runtime**, deeply reusing the cloud-native ecosystem. Within the given Goal constraints the Agent decides autonomously — task decomposition, tool invocation, context fetching — until the end-state is reached.\n\n```mermaid\nflowchart LR\n    G[\"Goal · desired end-state + acceptance criteria\"]\n    C[\"Context · SSOT / ADR / business boundaries\"]\n    A[\"Agent self-iteration loop\u003cbr/\u003eLLM-driven · re-plan against Goal each step\"]\n    E[\"Execute\u003cbr/\u003etask decomposition · tool calls · context fetch\"]\n    O[\"Observed State\u003cbr/\u003ecollected by observability tools\"]\n    V{\"Verifier\u003cbr/\u003ehas observed converged to desired?\"}\n    D[\"End-state reached\"]\n    G --\u003e A\n    C --\u003e A\n    A --\u003e E --\u003e O --\u003e V\n    V --\u003e|\"not converged · keep iterating\"| A\n    V --\u003e|\"converged\"| D\n```\n\n\u003e **Figure 1 · The Agent self-iteration loop.** Goal and Context are one-shot inputs. The Agent does not run a pre-frozen plan — it re-generates the plan against the Goal at every step, and the Verifier decides whether the loop stops.\n\n---\n\n## 2. Core Observations\n\n### 2.1 A single Goal-driven loop keeps expanding its reach\n\nAs model capability grows, an Agent loop built around one goal can cover an ever-larger problem space and run for ever-longer durations. By contrast, a traditional Harness assembled from multi-stage pipelines is more prone to **goal drift** once the run path gets long, eventually deviating from the user's original intent.\n\n\u003e A human's pre-frozen, immutable plan **will** drift; only a plan the Agent re-generates against the Goal at every step can converge.\n\n### 2.2 Context retrieval is shifting from centralized services to local search\n\nContext windows keep growing, and current SOTA coding agents commonly fetch context via local `grep` and file scans. This means a Context Service built on a centralized scheme such as RAG is losing importance in some development scenarios.\n\n### 2.3 Specs and Goals should be consume-once\n\nEvery Spec or Goal should be discarded once the task completes — it should not settle into long-lived system state. Humans and Agents rarely re-read these one-shot goal descriptions. **Anything that can be inferred from code, configuration, or the running environment should not be separately preserved as context.**\n\n### 2.4 The Verifier is the master switch for whether the whole system converges\n\nKubernetes reconciliation converges because both `desired state` and `observed state` are declarative and structured — the diff is near-zero-cost and unambiguous. But \"is the goal achieved?\" is an **AI-hard, expensive, ambiguous** judgment.\n\n\u003e A long-running Agent with a weak Verifier does not stop at a wrong state — it **confidently converges in the wrong direction**, because the loop itself rewards \"looks done.\"\n\nObservability and the Verifier are not the same thing: **the former tells you what happened; the latter judges whether you are closer to the end-state.**\n\n---\n\n## 3. Engineering Implementation\n\n### 3.1 Architecture call: control plane / data plane / memory\n\nThe **control plane** has three parts: a Goal file, a Context folder, and a Verifier.\n\n- The **Goal file** defines the task's desired end-state, and must contain executable acceptance criteria (tests, assertions, oracles) — not just a natural-language description of the end-state.\n- The **Context folder** holds only SSOT information that cannot be inferred from code or the running environment: config keys, deployment architecture, human constraints, business boundaries, organizational rules, and irreversible decision records (ADRs). Session-related information and derived queries are not context — they are a class of skills / tools.\n- The **Verifier** is peer-level with the Goal; it judges whether `observed state` is converging toward `desired state`. It must not be demoted into an accessory of Observability.\n\nThe **data plane** comprises Sandbox, Tools, Skills, MCP, CLI, security mechanisms, observability, and the Session Log. Together they let the Agent actually execute tasks, call tools, isolate risk, record the process, and track state. The observability component supplies the `observed state`.\n\n**On memory** — memory is fundamentally end-state management and traceability; it requires discarding the authority of intermediate state. The Session Log grows unbounded for a long-running Agent, so the Agent must rely on some compressed view to work:\n\n| Role | Position | Authority |\n|---|---|---|\n| **Session Log** | Write-Ahead Log. Append-only, never mutated | The only ground truth |\n| **SSOT** | Committed State. The committed authoritative state | Authoritative |\n| **Intermediate state** (summary, heuristics, index) | Materialized View / Cache. Usable because it is fast | **Never authoritative**; rebuildable from `SSOT + Log + Code`; invalidate and recompute whenever in doubt |\n\n\u003e A long-running Agent keeps summarizing its own dialogue, outputs, and behavior, settling them into heuristics — the root of distortion and error accumulation is treating the cache as truth. The fix is not to ban the cache, but to **forbid the cache from being promoted to truth**: the Agent still runs on the compressed view, but must always be able to fall back to the raw Log, and a summary is forever *derived*, never *authoritative*.\n\n### 3.2 Evolution path: the intelligent Workload\n\nAn Agent should no longer be understood as a continuous human-facing chat system — it should evolve into a **Workload**. In this form:\n\n- **Goal** is a one-shot human input that defines the task's desired end-state, not a continuously-interactive chat context. A good Goal is clear, result-verifiable, and preserves a large search space and high parallelism. Humans should not freeze the task into a linear pipeline — they should give the Agent enough autonomous planning room.\n- **Agent** is carried by a set of Runtimes; it runs long-lived and self-iterates inside the Runtime's execution environment, tool set, and security boundary, until `desired state` (defined by the Goal) and `observed state` (obtained by observability tools) converge.\n- **Runtime** is both the scheduling carrier and the execution tool for the Agent, carrying three duties:\n  - **Schedule Agents** — start, manage, resume, and terminate Agent instances based on Goal and Context;\n  - **Supply Agents** — respond to Agent requests by dynamically providing new Runtimes, Sandboxes, Tools, Skills, MCP, CLIs, or sub-Agents, forming an extensible, composable, recursive Agent Workload system;\n  - **Observe \u0026 roll back** — provide the Agent with a security boundary, observability, and the Session Log.\n\nThis pattern maps onto the relationship between Deployment, Controller, Pod, and the underlying Runtime in Kubernetes:\n\n| Kubernetes | Agent Infra | Responsibility |\n|---|---|---|\n| Deployment / Workload | Goal | Defines the desired end-state |\n| Controller | Operator + Verifier | Continuous scheduling and state convergence |\n| Pod | Agent execution unit | Executes concrete tasks |\n| Container Runtime | Agent Runtime | Provides the underlying execution environment; callable by upper layers and by the execution units themselves to create new units |\n\n```mermaid\nflowchart TB\n    subgraph K8S[\"1. Kubernetes — declarative diff → convergence guarantee\"]\n        direction TB\n        API[\"API Server · declarative entrypoint\"]\n        ETCD[\"etcd · cluster state SoT\"]\n        CM[\"Controller Manager · reconcile loop\"]\n        DEP[\"Deployment · desired end-state\"]\n        RS[\"ReplicaSet · maintain replica count\"]\n        POD[\"Pod xN · runtime\"]\n        API --- ETCD\n        CM --- API\n        DEP --\u003e RS --\u003e POD\n        CM --\u003e|\"diff: desired vs observed\"| RS\n    end\n    subgraph CS[\"2. CocoonSet — Goal+Context+Verifier → approach end-state\"]\n        direction TB\n        CR[\"CocoonSet CR\u003cbr/\u003eGoal + Context + Verifier\"]\n        CSOP[\"CocoonSet Operator · reconcile\"]\n        BRAIN[\"agent-main · Brain\u003cbr/\u003e+ Runtime Sidecar\"]\n        SUBP[\"Sub Pods xN · worker\"]\n        VER[\"Verifier · convergence master-switch\u003cbr/\u003etakes over what diff does in K8s\"]\n        SLOG[\"Session Log SoT · Append-only WAL\"]\n        CR --\u003e CSOP --\u003e BRAIN --\u003e SUBP\n        CSOP -.-\u003e|\"continue / terminate per verdict\"| VER\n        SUBP --\u003e|\"emit Draft\"| VER\n        BRAIN --- SLOG\n    end\n    K8S -.-\u003e|\"reuses semantics: CR vs Deployment · Verifier vs diff\"| CS\n```\n\n\u003e **Figure 3 · Control-plane / data-plane scheduling: Kubernetes vs CocoonSet.** CocoonSet reuses the K8s \"declarative workload + reconciliation\" semantics, extending \"workload\" into \"Agent workload.\" The one new first-class citizen is the **Verifier** — because in the Agent setting \"is it done?\" is AI-hard and cannot be settled by a zero-cost structured diff.\n\n### 3.3 Landing it: MindSet × CocoonSet × Runtime, three layers\n\n#### The three elements of MindSet\n\n| Element | Content |\n|---|---|\n| **Desired State (Goal)** | The task's desired end-state file. Not just a natural-language description — it must carry executable acceptance criteria. |\n| **Observed State (SSOT)** | The committed physical-fact state. Records committed environment information as the bedrock for later decisions. |\n| **Mind Agent container** | (1) Interaction \u0026 modeling — help the user shape the Goal, and abstract an observable State out of the SSOT; (2) Verifier role — act as the convergence master-switch, judging whether a Draft state is converging toward the Goal. |\n\n\u003e **The key shift:** a MindSet Operator brings up the Mind Agent Pod. After reaching consensus with the user, the Mind Agent dynamically configures a group of `CocoonSet`s (each mapping to one major-direction Task) and moves into the execution phase.\n\n```mermaid\nflowchart TB\n    subgraph L0[\"L0 · INPUT\"]\n        UG[\"User · Goal\u003cbr/\u003edesired end-state + acceptance criteria · consume-once\"]\n        CF[\"Context Folder\u003cbr/\u003eSSOT · ADR · business boundaries\"]\n        UN[\"User · rollback notice / intervention entry\"]\n    end\n    subgraph L1[\"L1 · MINDSET — top-level abstraction · AI decision \u0026 convergence\"]\n        MA[\"Mind Agent · single brain\u003cbr/\u003eparse Goal · decompose · re-plan each step\"]\n        DS[\"Desired State\u003cbr/\u003ederived from Goal · declarative · with acceptance criteria\"]\n        OS[\"Observed State · SSOT\u003cbr/\u003ecommitted authoritative state · written by Verifier\"]\n        VF[\"Verifier · convergence master-switch\u003cbr/\u003ehas observed converged to desired?\"]\n        CMT[\"Commit · update SSOT\"]\n        RB[\"User Feedback / Rollback\"]\n    end\n    subgraph L2[\"L2 · COCOONSET — scheduling \u0026 execution\"]\n        COP[\"cocoonset operator · controller\"]\n        MAIN[\"main agent · brain pod\"]\n        SUB[\"Sub Agents · workers · cross-platform sandbox\"]\n        DQ[\"Observed State Draft Queue\u003cbr/\u003ecandidate observation · pending review · materialized view\"]\n    end\n    subgraph L3[\"L3 · RUNTIME — execution environment\"]\n        SBX[\"Sandbox · isolation · scratchpad\"]\n        TOOL[\"Tools / Skills / MCP / CLI\"]\n        SL[\"Session Log · Append-only WAL\u003cbr/\u003eGround Truth · replayable \u0026 rollback-able\"]\n    end\n    UG --\u003e MA\n    CF -.-\u003e|\"context · read\"| MA\n    MA --\u003e|\"CR · GoalRef\"| COP\n    DS --\u003e VF\n    OS --\u003e VF\n    VF --\u003e|\"converged → commit\"| CMT\n    VF --\u003e|\"diverged → rollback\"| RB\n    CMT --\u003e OS\n    RB -.-\u003e|\"notify\"| UN\n    COP --\u003e MAIN\n    MAIN --\u003e SUB\n    SUB --\u003e|\"execute\"| SBX\n    SUB --\u003e TOOL\n    SUB --\u003e DQ\n    DQ -.-\u003e|\"draft observation → Verifier\"| VF\n    SUB --\u003e SL\n    SL -.-\u003e|\"log replay\"| RB\n```\n\n\u003e **Figure 4 · Agent Infra: MindSet × CocoonSet × Runtime.** Each layer has its job — **L1 MindSet** does AI decision-making and the convergence verdict, **L2 CocoonSet** does scheduling and execution, **L3 Runtime** provides the sandbox, tools, and Session Log. Control flows top-down as dispatch; drafts flow bottom-up to the Verifier; a commit writes back to the SSOT.\n\n#### CocoonSet: the underlying scheduling Operator\n\nUnder MindSet's direction, the **CocoonSet Operator** is the scheduler of the underlying Runtime, managing the concrete execution units.\n\n**Single Brain + Multi Workers:**\n\n- **Main Agent (Brain)** — handles task decomposition and logic execution. It periodically aggregates progress and pushes SSOT state diffs into the `Observed State Draft` queue.\n- **Tool containers (Hands)** — via CocoonSet's Tool capability, the Main Agent can call containers of different images. For example, the main logic runs in a Linux Codex image, while a specific compilation task is dispatched to a Windows Tool container.\n\n**State-verdict flow:**\n\n| Step | Participant | Action | Output |\n|---|---|---|---|\n| 1 · Execute | Main / Sub Agent | Run the task in the Sandbox and record the Session Log | `Observed Draft` |\n| 2 · Review | Verifier (MindSet) | Compare the Draft against the Desired State for divergence | Convergence verdict |\n| 3 · Commit | MindSet | If converged, update the SSOT file | `Committed State` |\n| 4 · Exception | MindSet | If not converged, trigger rollback or request user intervention | `Rollback Command` |\n\n```mermaid\nflowchart TB\n    UG[\"L0 · User · Goal\u003cbr/\u003euser-defined goal / desired end-state\"]\n    subgraph L1[\"L1 · MINDSET — top-level abstraction\"]\n        MA[\"Mind Agent\u003cbr/\u003eparse Goal · schedule CocoonSet · trigger rollback\"]\n        DS[\"Desired State\u003cbr/\u003edesired state · CR-like spec · declarative\"]\n        VF[\"Verifier · FOCUS · convergence verdict\u003cbr/\u003ecompare Desired vs Draft Queue\"]\n        OS[\"Observed State\u003cbr/\u003eSSOT · single source of truth · canonical\"]\n    end\n    subgraph L2[\"L2 · COCOONSET — execution domain\"]\n        COP[\"cocoonset operator · reconcile loop\"]\n        MAIN[\"main agent · main-path Draft\"]\n        SUB[\"sub agents · partial Draft\"]\n        DQ[\"Observed State Draft Queue\u003cbr/\u003ecandidate observed state · pending Verifier review\"]\n    end\n    subgraph L3[\"L3 · RUNTIME — underlying resources\"]\n        PODS[\"pods · runtime compute units\"]\n        TENV[\"tools / env · external tools \u0026 environment\"]\n        SL[\"Session Log · append-only\u003cbr/\u003eimmutable event stream · rebuild basis for Verifier \u0026 SSOT\"]\n    end\n    UG --\u003e MA\n    MA --\u003e|\"derive\"| DS\n    MA --\u003e|\"dispatch · CR / GoalRef\"| COP\n    DS --\u003e VF\n    OS --\u003e VF\n    VF --\u003e|\"converged → update SSOT\"| OS\n    VF --\u003e|\"diverged → feedback / rollback\"| MA\n    COP --\u003e MAIN\n    MAIN --\u003e SUB\n    SUB --\u003e|\"execute\"| PODS\n    PODS --- TENV\n    SUB --\u003e DQ\n    DQ --\u003e|\"submit drafts\"| VF\n    PODS --\u003e SL\n    SL -.-\u003e|\"replay / evidence\"| VF\n```\n\n\u003e **Figure 5 · MindSet top-level abstraction — the convergence \u0026 rollback architecture.** Top-down: User Goal → MindSet decision → CocoonSet execution → Runtime feedback → Verifier convergence verdict. **Converged** writes back to the SSOT; **not converged** feeds back / rolls back. The SSOT is only ever written by the Verifier, after convergence.\n\n### 3.4 Reversibility: determinism grounded in the Session Log\n\nTo handle the drift a long-running Agent may exhibit, the system mandates that every execution unit be **rollback-capable**.\n\n**The WAL nature of the Session Log** — the Session Log is treated as a Write-Ahead Log:\n\n- **Append-only** — records all raw decisions and side effects.\n- **Authoritative** — any intermediate Summary is forever *derived*; whenever in doubt, invalidate the cache and rebuild from the Log.\n\n**The rollback execution path** — when a rollback command arrives (passed via a specific field on the `CocoonSet` CR), each sub-Agent follows this logic:\n\n1. **Prompt constraint** — at startup the Agent is told: \"you are rollback-able based on the Log; lossy is acceptable, but it must be reversible.\"\n2. **Inverse operations** — using the Session Log records, inversely undo the physical side effects already produced (e.g. delete temporary resources, revert configuration).\n\n### 3.5 Observability metrics\n\nThe design philosophy lands on two levels, and convergence quality is measured by a set of observability metrics.\n\n**Cognitive level (MindSet):**\n\n- Emphasize \"consume-once\": the Goal is discarded once the task completes; it never settles into system state.\n- **The Verifier is the core**: do not demote the Verifier to an observability tool — it is the master switch that decides whether the system halts.\n\n**Physical level (Runtime):**\n\n- **No cache usurpation**: a cache is only for speed; it must never be promoted to Truth.\n- **Heterogeneous execution power**: physical isolation for cross-platform task execution, solved through multi-image Tool containers.\n\n```mermaid\nflowchart TB\n    subgraph CPLANE[\"Control Plane — Desired State + Verdict\"]\n        CR[\"CocoonSet CR\u003cbr/\u003eGoalRef · ContextRef · VerifierRef\"]\n        OP[\"Operator · Reconciler\u003cbr/\u003ereconcile CocoonSet · orchestrate main / sub · continue or terminate per Verifier\"]\n        BRAIN[\"agent-main · Single Brain\u003cbr/\u003edecompose Goal · re-plan each step · no direct side-effect rights\"]\n        VER[\"Verifier · convergence gate · first-class\u003cbr/\u003ecloser to the end-state? — the sole arbiter\"]\n        SLOG[\"Session Log · SoT\u003cbr/\u003eWrite-Ahead Log · Append-only, tamper-proof\"]\n        SEC[\"Security \u0026 Permissions\u003cbr/\u003eidentity auth · side-effect guard · permission boundary\"]\n    end\n    subgraph DPLANE[\"Data Plane — Actual State\"]\n        SIDE[\"Runtime Sidecar\u003cbr/\u003eIntent gateway · sole execution channel · Brain absent → Idle\"]\n        SUBA[\"Sub Agents · multi-hand · free clone \u0026 scale\u003cbr/\u003eWindows / Linux / macOS Pod\"]\n        K8S[\"K8s interface layer\u003cbr/\u003ePod/RS · Job/DS · native lifecycle · CocoonSet vs Deployment\"]\n        TOS[\"TOS shared mount\u003cbr/\u003eobject-level ACL · Epoch Artifact persistence\"]\n        SBX[\"Sandbox · Tools · MCP · CLI\u003cbr/\u003eisolated execution · all calls via Sidecar\"]\n    end\n    subgraph OBSV[\"Observability — aggregated from Session Log \u0026 Sidecar\"]\n        M1[\"Goal Completion Rate = done / total\u003cbr/\u003eVerified by Verifier\"]\n        M2[\"Interruption Rate = interrupted / total\u003cbr/\u003eClassified by Verifier\"]\n        M3[\"Retry Rate · Active/Idle ratio A/I · side-effects blocked N\"]\n    end\n    CR --\u003e|\"spec\"| OP\n    OP --\u003e|\"orchestrate\"| BRAIN\n    BRAIN --\u003e VER\n    VER --\u003e|\"verdict\"| OP\n    BRAIN --\u003e|\"decisions append\"| SLOG\n    BRAIN --\u003e|\"dispatch intent\"| SIDE\n    SEC --- SIDE\n    SIDE --\u003e SUBA\n    SUBA --\u003e K8S\n    SUBA --\u003e TOS\n    SUBA --\u003e SBX\n    SIDE --\u003e|\"append-only\"| SLOG\n    SLOG --\u003e OBSV\n```\n\n\u003e **Figure 6 · Agent Workload — Infra capability map \u0026 observability metrics.** The control plane declares the end-state and the Verifier judges convergence; the data plane produces side effects only through the Runtime Sidecar — the sole execution channel; all metrics aggregate from the Session Log and Sidecar metrics, and **the definition of the core metrics is owned by the Verifier** — \"Goal Completion Rate\" and \"Interruption Rate\" are judged / classified by the Verifier, not guessed from log keywords.\n\n---\n\n## 4. Today vs Planned\n\nThis design lands in two steps. **CocoonSet is the substrate already running**; **MindSet is the cognitive layer above it.**\n\n### 4.1 CocoonSet\n\n- **CRD**: `cocoonset.cocoonstack.io/v1`, Kind `CocoonSet` (short name `cs`), reconciled by `cocoon-operator`, admission-validated by `cocoon-webhook`.\n- **The Agent-shape discriminator field**: `spec.agent.kind` —\n  - `kind: desktop` (default): cloud-desktop workload — human RDP / SSH desktops, replica clone-out;\n  - `kind: autonomous`: the self-driving Agent workload — an LLM self-iteration loop + sub-Pod workers, requiring a `goalRef` or an inline `goal`.\n- **Runtime model**: `vk-cocoon` is the virtual-kubelet provider; it registers each EBM bare-metal host as one K8s node. Pods derived by the Operator are scheduled onto those nodes, and the `cocoon` CLI brings up the MicroVMs.\n\n### 4.2 MindSet (planned)\n\nWhat MindSet adds above CocoonSet is the **cognitive layer**:\n\n| Capability | Today (CocoonSet) | What MindSet adds |\n|---|---|---|\n| Convergence verdict | Operator reconciles replica count / node selection via structured diff | Verifier judging the AI-hard question \"closer to the end-state?\" |\n| Goal modeling | `goalRef` / inline `goal` (one Goal per CocoonSet) | A **Mind Agent** reaches Goal consensus with the user and splits it into a group of CocoonSets |\n| Multi-task orchestration | One CRD, one workload | A MindSet Operator brings up the Mind Agent, which dynamically configures multiple CocoonSets |\n| Rollback | Pod-level teardown | **Deterministic rollback based on the Session Log** — inversely undo physical side effects |\n| Memory | Session Log (per Pod) | A three-tier memory model — SSOT / WAL / Materialized View — forbidding cache usurpation |\n\nLanding order: first **promote the Verifier to a first-class citizen**, then **multi-CocoonSet orchestration**, and finally **Mind Agent interaction modeling**.\n\n---\n\n## 5. Design Philosophy: the one-line principle list\n\n1. **An Agent is a Workload, not a chat box** — driven by a Goal, self-iterating in a Runtime until convergence.\n2. **A human's plan will always drift** — only a plan re-generated against the Goal at every step can converge.\n3. **Goals / Specs are consume-once** — anything inferable from code and environment is not separately stored as context.\n4. **The Verifier is the convergence master switch** — it judges \"closer to the end-state?\"; Observability only answers \"what happened?\"\n5. **The cache must not usurp** — a summary is forever derived; the Session Log (WAL) is the ground truth.\n6. **Reversibility is a hard constraint** — lossy is acceptable, but it must be rollback-able based on the Log.\n7. **Reuse cloud-native semantics** — `CR ≈ Deployment`, `Verifier ≈ diff`; reuse the K8s reconciliation mental model.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcocoonstack%2Fmindset","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcocoonstack%2Fmindset","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcocoonstack%2Fmindset/lists"}