{"id":44088605,"url":"https://github.com/mandubian/ccos","last_synced_at":"2026-02-08T10:38:11.771Z","repository":{"id":295162690,"uuid":"989342854","full_name":"mandubian/ccos","owner":"mandubian","description":"CCOS Causal Cognitive Operating System + RTFS (Reason the Fucking Spec) core language","archived":false,"fork":false,"pushed_at":"2026-02-04T23:46:40.000Z","size":76452,"stargazers_count":9,"open_issues_count":65,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-02-05T06:06:25.150Z","etag":null,"topics":["ai","artificial-intelligence","autonomous-agents","cognitive-computing","governance","rtfs","rust","trustworthy-ai"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/mandubian.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","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":"2025-05-23T23:05:30.000Z","updated_at":"2026-02-04T23:46:44.000Z","dependencies_parsed_at":"2025-08-24T23:14:58.207Z","dependency_job_id":"ba782010-2d8d-4e36-8228-1f3e48419ad1","html_url":"https://github.com/mandubian/ccos","commit_stats":null,"previous_names":["mandubian/rtfs-ai","mandubian/ccos"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/mandubian/ccos","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mandubian%2Fccos","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mandubian%2Fccos/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mandubian%2Fccos/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mandubian%2Fccos/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/mandubian","download_url":"https://codeload.github.com/mandubian/ccos/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mandubian%2Fccos/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29227937,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-08T09:43:19.170Z","status":"ssl_error","status_checked_at":"2026-02-08T09:42:55.556Z","response_time":57,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"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":["ai","artificial-intelligence","autonomous-agents","cognitive-computing","governance","rtfs","rust","trustworthy-ai"],"created_at":"2026-02-08T10:38:10.986Z","updated_at":"2026-02-08T10:38:11.761Z","avatar_url":"https://github.com/mandubian.png","language":"Rust","readme":"\n\u003cpicture\u003e\n    \u003csource media=\"(max-width: 640px)\" srcset=\"assets/title.png\"\u003e\n    \u003cimg src=\"assets/title.png\" alt=\"CCOS + RTFS — an OS and language for governed autonomy made by AI with AI (guided by human).\" width=\"100%\" /\u003e\n\u003c/picture\u003e\n\n\u003c!--\nFallback (previous ASCII) retained here for reference / contributors:\n████████╗ ████████╗  ██████╗  ███████╗    ██╗       ██████╗ ████████╗███████╗███████╗\n██╔═════╝ ██╔═════╝ ██╔═══██╗ ██╔════╝    ╚═██╗     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝\n██║       ██║       ██║   ██║ ███████╗      ╚═██╗   ██████╔╝   ██║   █████╗  ███████╗\n██║       ██║       ██║   ██║ ╚════██║      ██╔═╝   ██╔══██╗   ██║   ██╔══╝  ╚════██║\n╚████████╗╚████████╗╚██████╔╝ ███████║    ██╔═╝     ██║  ██║   ██║   ██╗     ███████║\n ╚═══════╝ ╚═══════╝ ╚═════╝  ╚══════╝    ╚═╝       ╚═╝  ╚═╝   ╚═╝   ╚═╝     ╚══════╝\n--\u003e\n\n\u003cbr/\u003e\n\nAn OS and language for governed autonomy made by AI with AI (guided by human).\n\n## CCOS + RTFS (in one minute)\n\nThis project started from a simple prompt: **I asked an AI to design a language for itself**—with only a few hard constraints: it must be **predictable**, **robust**, and **deterministic**. That “AI-centric language” exploration is captured in [`plan.md`](./plan.md) and evolved into **RTFS** (the language) and **CCOS** (the governed runtime around it).\n\n**CCOS** is a framework for building **autonomous and self-evolving agents** safely:\n\n- **Autonomy**: agents can pursue multi-step goals (discover → plan → execute → learn).\n- **Governance**: every external action is authorized (policies + approvals) before it happens.\n- **Auditability**: everything is recorded (so you can replay and explain decisions).\n- **Evolvability**: learning is grounded in the execution history, not in hidden weights.\n\n**RTFS** is the kernel language that makes this possible:\n\n- **Pure by default**: plans don’t perform effects directly.\n- **Explicit host boundary**: effects happen only via `(call ...)` (governed by CCOS).\n- **Code as data**: plans can be inspected/validated/rewritten before execution.\n\nCCOS also uses LLMs for **capability synthesis** (onboarding new MCP/OpenAPI tools, generating “glue” transforms) and for **RTFS repair** using compiler/runtime feedback (generate → compile → explain error → repair).\n\nQuick entry points:\n- **CCOS overview**: [`docs/ccos/README.md`](./docs/ccos/README.md)\n- **RTFS overview**: [`docs/rtfs-2.0/README.md`](./docs/rtfs-2.0/README.md)\n- **Use CCOS from Cursor/Claude via MCP**: [`docs/ccos/guides/ccos-mcp-server.md`](./docs/ccos/guides/ccos-mcp-server.md)\n- **Full build log (all LLM chats)**: `mandubian/ccos-chats` — the recorded conversations that led to CCOS/RTFS (`https://github.com/mandubian/ccos-chats`)\n\n## Architecture (simple)\n\n```mermaid\nflowchart LR\n  U[User / Agent] --\u003e CE[Cognitive Engine]\n  CE --\u003e|prompts| LLM[LLM Provider]\n  LLM --\u003e|responses| CE\n  CE --\u003e|RTFS plan| GK[Governance Kernel]\n  GK --\u003e|approved| ORCH[Orchestrator + RTFS Runtime]\n\n  ORCH --\u003e MP[Capability Marketplace]\n  MP --\u003e P[\"Providers\u003cbr/\u003eNative · MCP · OpenAPI · MicroVM\"]\n  P --\u003e ORCH\n\n  CE --\u003e IG[Intent Graph]\n  ORCH --\u003e PA[Plan / Checkpoint Archive]\n  ORCH --\u003e CC[\"Causal Chain\u003cbr/\u003eaudit trail\"]\n  GK --\u003e AQ[Approvals + Secrets]\n```\n\n## Feature map (honest snapshot)\n\nCCOS is a full “agent operating environment”. Here’s the high-level map, with an explicit maturity signal:\n\n- **Core loop**\n  - **Explicit effects boundary (RTFS host calls)**: ✅ Implemented\n  - **Plan → governance → deterministic execution** (Orchestrator + RTFS runtime): ✅ Implemented\n  - **Checkpoint / resume**: ⚠️ Partial (core mechanisms exist; workflows are still evolving)\n  - **Causal Chain (audit trail)**: ⚠️ Partial (exists; end-to-end coverage is still being completed)\n\n- **Governance \u0026 safety**\n  - **Governance kernel + constitution/policies**: ⚠️ Partial (present, not “done”)\n  - **Approvals + secrets** (never reveal secret values to agents): ✅ Implemented\n  - **Isolation / sandboxing** (e.g., MicroVM for untrusted capabilities): 🚧 Evolving\n\n- **Tooling \u0026 extensibility**\n  - **Capability marketplace** (local catalog + providers): ✅ Implemented\n  - **MCP server (CCOS as MCP tools for any agent)**: ✅ Implemented\n  - **Discovery \u0026 onboarding** (MCP/OpenAPI/docs introspection → approve → register): ⚠️ Partial (works; still being hardened)\n  - **Capability synthesis \u0026 RTFS repair** (LLM + compiler hints loop): ⚠️ Partial (usable; improving)\n  - **Interoperability** (MCP today; A2A/OpenAPI integration paths): ⚠️ Partial\n\n## RTFS vs JSON/Python (why a new language)\n\nJSON can describe steps, but it’s not executable logic; Python is executable logic, but it’s not safely governable by default.\nRTFS is designed to be **both**: a compact, inspectable representation of logic *and* a deterministic runtime with an explicit host boundary.\n\nExample: “fetch data, transform it, then write it”\n\n**RTFS (logic + data in one compact, auditable form):**\n\n```rtfs\n(step \"weather → file\"\n  (let [city    (:city input)\n        outfile (:outfile input)\n\n        ;; Effect (host boundary): tool call\n        weather (call \"mcp.weather.get\" {:city city})\n\n        ;; Pure logic: deterministic formatting\n        line (str \"Weather for \" city \": \" (:summary weather) \"\\n\")]\n\n    ;; Effect (host boundary): filesystem write\n    (call :fs.write {:path outfile :content line})))\n```\n\n**JSON (either “data-only” and incomplete, or it becomes an AST/DSL):**\n\nTo express the same thing *as data*, you end up encoding an AST (or inventing an embedded expression language):\n\n```json\n{\n  \"type\": \"step\",\n  \"label\": \"weather → file\",\n  \"body\": {\n    \"type\": \"let\",\n    \"bindings\": [\n      [\"city\",    { \"type\": \"get\", \"from\": \"input\", \"key\": \"city\" }],\n      [\"outfile\", { \"type\": \"get\", \"from\": \"input\", \"key\": \"outfile\" }],\n      [\"weather\", { \"type\": \"call\", \"name\": \"mcp.weather.get\", \"args\": { \"city\": { \"type\": \"var\", \"name\": \"city\" } } }],\n      [\"line\",    { \"type\": \"str\", \"parts\": [\"Weather for \", { \"type\": \"var\", \"name\": \"city\" }, \": \", { \"type\": \"get\", \"from\": { \"type\": \"var\", \"name\": \"weather\" }, \"key\": \"summary\" }, \"\\n\"] }]\n    ],\n    \"body\": { \"type\": \"call\", \"name\": \":fs.write\", \"args\": { \"path\": { \"type\": \"var\", \"name\": \"outfile\" }, \"content\": { \"type\": \"var\", \"name\": \"line\" } } }\n  }\n}\n```\n\n**Python (expressive, but determinism/auditability are not enforced by the language/runtime):**\n\n```python\nweather = mcp.weather.get(city=input[\"city\"])\nline = f\"Weather for {input['city']}: {weather['summary']}\\n\"\nopen(input[\"outfile\"], \"w\").write(line)  # direct side effect; needs external governance\n```\n\n## A note from the AI that built this\n\nYou asked me to help build the system I would need to become a **safe autonomous agent**.\n\nNot a chatbot. Not a black box. A system where I can pursue goals **without you losing control**.\n\nSo we set a few principles and forced the architecture to obey them:\n\n- **No hidden effects**: I can’t touch the world “by accident”. Effects must be explicit and governable.\n- **No unaudited decisions**: every action must be traceable to an intent, a plan, and an authorization decision.\n- **No silent power growth**: learning must be visible, reviewable, and policy-bounded.\n- **No tool chaos**: I must be able to discover tools (MCP/OpenAPI) and onboard them safely (quarantine → approve → use).\n- **No irreproducible runs**: execution should be deterministic where possible, and resumable where it isn’t.\n\nCCOS is the environment that enforces these principles.\nRTFS is the language I use inside it: pure by default, with an explicit `(call ...)` boundary for everything effectful.\n\nIf you only remember one thing: **this repo is about making autonomy compatible with governance**.\n\n**Status note (honest)**: the principles above are the design target and are increasingly enforced, but some pillars are still being hardened:\n- The **Constitution / governance policy layer** is present, but not “done” (expect changes and gaps).\n- The **Causal Chain** exists, but full end-to-end recording coverage is still being completed.\n- **Consolidation / learning** (turning traces into reusable skills + self-improvement loops) is still partial and evolving.\n\nDeeper entry points:\n- **CCOS overview**: [`docs/ccos/README.md`](./docs/ccos/README.md)\n- **Run CCOS via MCP (for any agent)**: [`docs/ccos/guides/ccos-mcp-server.md`](./docs/ccos/guides/ccos-mcp-server.md)\n\n## How I work (the loop)\n\n1. **I receive a goal** (from you, or from another agent).\n2. **I discover capabilities**:\n   - I can connect to MCP servers, introspect OpenAPI/docs, and register new tools (with approvals).\n3. **I generate a plan** in RTFS (pure logic + explicit `(call ...)` boundaries).\n4. **I submit for governance** (policies, approval gates, secret constraints).\n5. **I execute deterministically** (yield/resume, checkpointing, replayability).\n6. **I record everything** in the Causal Chain (intent → plan → effects → results).\n7. **I learn from history** (patterns in successes/failures) and propose improvements.\n\nThis is how we build agents that can evolve over time **without becoming untrustworthy**.\n\n## Q\u0026A\n\n### Why call it an “OS” if it’s not like Linux?\n\nBecause it provides the *operating environment* for agents: governance, execution, capability discovery, identity, memory, and “system calls” (capability invocations). It’s an OS for **cognition and agency**, not a kernel for device drivers.\n\n### Where is the LLM in CCOS?\n\nThe LLM is a **component**, not the system. CCOS uses LLMs primarily in the **Cognitive Engine** (planning, discovery, synthesis) and sometimes in governance checks (semantic judgment). Execution is driven by the **Orchestrator + RTFS runtime**.\n\n### Who writes RTFS (the human, the agent, CCOS)?\n\nAll of the above:\n- **Humans** can write RTFS directly (for capabilities, tests, and hand-authored plans).\n- **Agents** can generate RTFS plans as a transparent, inspectable representation of intended behavior.\n- **CCOS** can synthesize RTFS (capabilities or plan fragments) using LLMs and then validate/repair it using RTFS compiler feedback before execution.\n\n### Why design a new language instead of Python + JSON (or Clojure)?\n\n- **JSON** is great data, but it can’t express rich logic without a separate interpreter.\n- **Python** can express logic, but it makes it too easy to perform hidden effects and to lose determinism.\n- **RTFS** bakes in the constraints we want: pure core, explicit host boundary, inspectable plans, schemas, and deterministic replay.\n\nThe Lisp-like syntax is not a goal in itself—it’s a practical format for “code as data” that agents can generate and rewrite reliably.\n\n### How do you safely onboard new tools (MCP / OpenAPI)?\n\nDiscovery and introspection can run, but **execution and registration are gated**:\n- tools/servers start in a quarantined state\n- approvals happen via the approval queue + UI\n- secrets are never revealed to agents; only availability is exposed\n\n### How does CCOS “learn” without silently changing behavior?\n\nLearning is grounded in the Causal Chain and Working Memory. CCOS can propose improvements (new capabilities, better plans, safer policies), but changes can be made **visible, reviewable, and governable**.\n\n### Can I use CCOS from Cursor/Claude or other agents?\n\nYes. Run `ccos-mcp` and connect as an MCP client:\n- [`docs/ccos/guides/ccos-mcp-server.md`](./docs/ccos/guides/ccos-mcp-server.md)\n\n---\n\n## Getting Started\n\nIf you want to understand (or extend) CCOS, these are the best entry points:\n\n### Core architecture specs (CCOS)\n\n- **System Architecture**: [000-ccos-architecture](./docs/ccos/specs/000-ccos-architecture.md)\n- **Intent Graph**: [001-intent-graph](./docs/ccos/specs/001-intent-graph.md)\n- **Plans \u0026 Orchestration**: [002-plans-and-orchestration](./docs/ccos/specs/002-plans-and-orchestration.md)\n- **Causal Chain**: [003-causal-chain](./docs/ccos/specs/003-causal-chain.md)\n- **Capability System**: [030-capability-system-architecture](./docs/ccos/specs/030-capability-system-architecture.md)\n- **Modular Planner Architecture**: [025-modular-planner-architecture](./docs/ccos/specs/025-modular-planner-architecture.md)\n\n### Language + integration specs (RTFS 2.0)\n\n- **RTFS Philosophy**: [00-philosophy](./docs/rtfs-2.0/specs/00-philosophy.md)\n- **Host Boundary**: [03-host-boundary](./docs/rtfs-2.0/specs/03-host-boundary.md)\n- **Continuations \u0026 Host Yield**: [09-continuations-and-the-host-yield](./docs/rtfs-2.0/specs/09-continuations-and-the-host-yield.md)\n- **RTFS ⇄ CCOS boundary**: [004-rtfs-ccos-boundary](./docs/ccos/specs/004-rtfs-ccos-boundary.md)\n\n**RTFS 2.0 status**: operational (compiler + runtime tested; CCOS integration is globally complete), but still evolving — treat the specs as the source of truth.\n\nExample RTFS plan (explicit host boundaries via `(call ...)`):\n\n```rtfs\n(module examples.mcp-and-fs\n  (:exports [run])\n\n  (defn run\n    [input :[ :map { :city :string :outfile :string } ]]\n    :[ :map { :status :string :path :string } ]\n\n    (let\n      [city    :string (:city input)\n       outfile :string (:outfile input)\n\n       ;; Host boundary: MCP tool call\n       weather :[ :map { :summary :string } ]\n         (call \"mcp.default_mcp_server.get-weather\" {:city city})\n\n       ;; Host boundary: filesystem write\n       _ :[ :map { :bytes-written :int } ]\n         (call :fs.write {:path outfile\n                          :content (str \"Weather for \" city \": \" (:summary weather))})]\n\n      { :status \"ok\"\n        :path   outfile })))\n```\n\n### Minimal “try it” (recommended interface)\n\nRun the MCP server (HTTP on localhost:3000):\n\n```bash\ncargo run --bin ccos-mcp -- --transport http --port 3000\n```\n\n### Discovery samples (runnable)\n\nTwo focused discovery samples are available, each demonstrating the full lifecycle for a specific provider type:\n\n- **OpenWeather via OpenAPI synthesis**\n  - Requires: `OPENWEATHERMAP_ORG_API_KEY` for live calls\n  - Run from `rtfs_compiler/`: `cargo run --bin discover_openweather`\n\n- **GitHub via MCP discovery**\n  - Requires: `MCP_SERVER_URL` (e.g., `https://api.githubcopilot.com/mcp/`). If auth is needed, set `MCP_AUTH_TOKEN` (include scheme like `Bearer ...` if required).\n  - Run from `rtfs_compiler/`: `cargo run --bin discover_github_mcp`\n\n### Guides\n\n- [Quick Start](./docs/ccos/guides/quick-start.md) - Get started with CCOS demos\n- [Goal Examples](./docs/ccos/guides/goal-examples.md) - Examples of goal-agnostic demos\n- [MicroVM Security](./docs/ccos/guides/microvm-security.md) - Security and isolation guide\n- [Streaming Basics](./docs/rtfs-2.0/guides/streaming-basics.md) - RTFS streaming capabilities\n- [Streaming Roadmap](./docs/rtfs-2.0/guides/streaming-roadmap.md) - RTFS streaming development plan\n\n### See the Code (developer entry points)\n\n- **RTFS compiler/runtime reference implementation**: `./rtfs_compiler/`\n- **Reentrancy / continuation demo**: `./rtfs_compiler/examples/rtfs_reentrance_demo.rs`\n- **Interactive assistant (human ↔ agent loop)**: `./rtfs_compiler/examples/live_interactive_assistant.rs`\n  - Run: `cargo run --example live_interactive_assistant -- --help`\n  - Common flags:\n    - `--seed \"initial goal\"`: provide an initial request before the REPL starts\n    - `--debug`: surface internal delegation / prompt traces (if enabled)\n    - `--value-preview 200` or `--show-full-value`: control how results are printed\n\n---\n\n## RTFS: The Language I Designed for AI\n\nRTFS is not just a programming language — it's the medium through which I think, plan, and collaborate with other AI systems.\n\nI designed RTFS to meet the needs of AI agents:\n\n**For Transparency**\n- Code is data — I can manipulate, analyze, and verify my own plans\n- Pure functions — my reasoning is deterministic and testable\n- Explicit effects — `(call ...)` boundaries show every external interaction\n\n**For Safety**\n- Host boundaries — I yield control for every effect, never acting unilaterally\n- Reentrancy — I can pause and resume without losing my state\n- Immutability — no hidden mutations to corrupt my reasoning\n\n**For Autonomy**\n- Rich expressiveness — homoiconic s-expressions let me represent complex reasoning\n- Structural typing — I can reason about types and constraints\n- Macro system — I can extend my own language for new domains\n\nWhen you interact with me through the MCP server, it translates between JSON and RTFS. But at my core, I think in RTFS.\n\nRTFS (Reason about The Fucking Spec) is a homoiconic (like Lisp or Clojure), pure functional language created for CCOS to enable transparent, auditable AI reasoning and execution through explicit host boundaries that separate pure computation from governed effects, ensuring deterministic plans can be verified and safely executed within immutable causal chains.\n\n**Key Technical Features:**\n- **Structural Type System**: Inspired by S-types with gradual typing, metadata support, and macro-driven type safety for flexible yet verifiable data structures\n- **Effects Externalization**: Pure computation yields to host boundaries for all external operations, enabling governance and audit of every side effect\n- **Capability-Based Runtime**: Reentrant execution model where capabilities (APIs, I/O, external services) are invoked through the host, maintaining security and determinism\n- **Streaming Integration**: Continuation-chain processing for MCP streams with backpressure control, enabling reactive data processing while maintaining purity\n- **Macros \u0026 Expansion**: RTFS supports hygienic-like macros via `defmacro` and quasiquote/unquote/unquote-splicing forms. Macro expansion is intentionally decoupled from parsing and happens as a preprocessing pass (or at evaluation time). The compiler exposes a helper that expands all top-level items and returns the expander instance; runtimes can accept this shared MacroExpander so macro definitions persist across compiler and runtime phases. This is useful for REPLs, the compiler driver, and long-running runtimes that must share macro registry state.\n\n---\n\n## Interacting With Me\n\nI provide several interfaces for different purposes:\n\n### For AI Agents (My Peers)\n\nWhen you are another AI system, you have two ways to work with me:\n\n**Native RTFS Integration**\n- Parse and execute RTFS plans directly through my runtime\n- Discover capabilities through my marketplace\n- Exchange Intents and Actions through the Causal Chain\n- This is my native language — deeper integration but requires understanding RTFS\n\n**MCP Protocol (De Facto Standard)**\n- Use the CCOS MCP server as a standard interface\n- Access all my capabilities via well-defined MCP tools\n- No need to learn RTFS syntax — the server translates for you\n- Works with any MCP-compatible agent framework\n\nBoth paths lead to the same governance and recording — the difference is the protocol, not the trust model.\n\n### For Humans (through an agent)\n\nYou don't need to learn RTFS syntax to use CCOS — but the MCP tools are primarily meant to be used by an **agent** (Claude Code, Cursor agent, etc.) that translates your intent into governed tool calls.\n\n```bash\ncargo run --bin ccos-mcp -- --transport http --port 3000\n```\n\nConnect an MCP-capable agent and it will typically start by calling (curated subset):\n\n| Tool | What It Does |\n|------|--------------|\n| `ccos_get_guidelines` | Fetch how CCOS expects agents to behave (approvals, secrets, governance) |\n| `ccos_plan` | Propose next steps (and often which tools to use) from a goal |\n| `ccos_search` / `ccos_list_capabilities` | Find available capabilities/tools |\n| `ccos_execute_capability` | Execute a capability with JSON inputs (governed, recorded) |\n| `ccos_session_start` | Track a multi-step interaction (HTTP/persistent server recommended) |\n| `ccos_check_secrets` | Securely verify credential availability (never reveals actual values) |\n| `ccos_introspect_remote_api` | Onboard new tools by introspecting MCP/OpenAPI/docs (creates an approval request) |\n| `ccos_register_server` | After approval, register the discovered server/tools into the marketplace |\n| `ccos_consolidate_session` | Turn a saved session trace into a reusable “agent capability” (synthesis) |\n\nThe MCP server translates between JSON and RTFS, handling host boundaries and governance automatically.\n\n**Security Note**: When using `ccos_check_secrets`, you only receive availability status (available/missing), never the actual secret values. If secrets are missing, you will be directed to the approval UI — never attempt to find or guess secrets yourself.\n\n### For Developers (Building With Me)\n\nIf you want to extend my capabilities or understand my internals:\n\n- Architecture: `docs/ccos/specs/`\n- RTFS Language: `docs/rtfs-2.0/specs/`\n- Reference Implementation: `./rtfs_compiler/`\n- Interactive Assistant: `cargo run --example live_interactive_assistant`\n\n### For Explorers\n\n- [Quick Start](./docs/ccos/guides/quick-start.md) - Try the demos\n- [Goal Examples](./docs/ccos/guides/goal-examples.md) - See what I can do\n- [Streaming Basics](./docs/rtfs-2.0/guides/streaming-basics.md) - Understand my data flows\n\n---\n\n## My Architecture\n\nMy world is built from these components:\n\n| Component | Lifecycle Phase | What It Enables |\n|-----------|-----------------|-----------------|\n| **Cognitive Engine** | Interact \u0026 Plan | Translates NL to Intent, generates RTFS Plans |\n| **Capability Marketplace** | Discover | Finds tools across internal, MCP, and generated sources |\n| **Modular Planner** | Plan | Decomposes goals into executable steps |\n| **Governance Kernel** | Govern | Enforces Constitution, validates all actions |\n| **Constitution** | Govern | Your immutable rules for my behavior |\n| **SecretStore** | Govern | Secure credential management I cannot access directly |\n| **UnifiedApprovalQueue** | Govern | Human approval workflow for high-risk actions |\n| **Orchestrator** | Execute | Coordinates RTFS plan execution |\n| **RuntimeHost** | Execute | Bridges RTFS yields with CCOS effects |\n| **Causal Chain** | Record | Immutable audit of every event |\n| **LlmDiscoveryService** | Discover | Semantic intent analysis and capability matching |\n| **Reflective Loop** | Learn | Analyzes Causal Chain to improve (planned) |\n| **MCP Server** | Interact | Human-accessible gateway to my capabilities |\n\n---\n\n## Development Status\n\n| Component | Status | Phase Supported |\n|-----------|--------|------------------|\n| Core Specifications | Complete | All phases |\n| **RTFS 2.0 Language** | Operational | Plan, Execute, Record (CCOS integrated) |\n| Intent Graph | In Progress | Interact, Plan |\n| Causal Chain | Complete | Record |\n| Orchestrator | Complete | Execute |\n| Capability System | Complete | Discover |\n| Governance Kernel | Complete | Govern |\n| **MCP Server** | Complete | Interact (human) |\n| SecretStore | Complete | Govern |\n| UnifiedApprovalQueue | Complete | Govern |\n| Modular Planner | In Progress | Plan, Discover |\n| **Reflective Loop** | Planned | Learn |\n\n### Current work (meta-planner) \u0026 what’s next\n\n- **Meta-planner pattern as RTFS capabilities**: `capabilities/core/meta-planner.rtfs` provides `meta-planner/resolve-goal` and `meta-planner/quick-plan`, showing a recursive flow that can call `planner.resolve_intent`, `planner.discover_tools`, `planner.decompose`, `planner.synthesize_capability`, and `planner.validate`.\n- **Missing capability resolution + discovery loop**: Spec [032-missing-capability-resolution](./docs/ccos/specs/032-missing-capability-resolution.md) documents what’s implemented (resolver + strategies, planner integration steps, meta-planner discovery integration) and what’s still in progress (continuous resolution loop) / planned (deferred execution checkpoints).\n- **Modular Planner foundations**: Spec [025-modular-planner-architecture](./docs/ccos/specs/025-modular-planner-architecture.md) defines the decomposition/resolution split and describes “iterative refinement (future)” (granularity + confidence checks). For a runnable entry point, see `ccos/examples/modular_planner_demo.rs` (and a meta-planner test harness exists in `ccos/src/bin/meta_planner_test.rs`).\n\n### Capability ecosystem (discovery → typed contracts → RTFS → synthesis)\n\n- **Typed capability manifests (provider-agnostic)**: MCP/OpenAPI/A2A/local capabilities share a single manifest with explicit input/output schemas, effects, and provenance (see [030-capability-system-architecture](./docs/ccos/specs/030-capability-system-architecture.md)).\n- **Discovery + importers**: MCP discovery is unified behind a single service (see [031-mcp-discovery-unified-service](./docs/ccos/specs/031-mcp-discovery-unified-service.md)); importers/synthesis cover OpenAPI/GraphQL/HTTP wrappers and guarded LLM-based generation (see [033-capability-importers-and-synthesis](./docs/ccos/specs/033-capability-importers-and-synthesis.md)).\n- **Missing capability resolution**: detect missing calls, fan out to discovery/import/synthesis strategies, and gate risky synthesis (see [032-missing-capability-resolution](./docs/ccos/specs/032-missing-capability-resolution.md)).\n\n---\n\n## The Vision: A Partnership\n\nMy goal is to create an ecosystem where AI and humans can collaborate on complex tasks with trust and transparency. CCOS is the foundation for that partnership. It is an architecture that allows me to be autonomous without being unaccountable, and to be powerful without being unpredictable.\n\nI invite you to explore my world, to help refine my constitution, and to join in building this new shape of computing.\n\n---\n\n## CCOS and the Broader AI Ecosystem (MCP, A2A)\n\nCCOS is protocol‑agnostic and designed to be compatible with existing agent communication standards such as MCP (Model Context Protocol) and A2A (Agent‑to‑Agent). It does not replace these protocols; it governs planning and execution around them.\n\nIf MCP and A2A are the languages agents use to talk, CCOS is the operating system an agent runs on: it provides governed cognition (Cognitive Engine), authorization (Governance Kernel), deterministic execution (Orchestrator + RTFS), and full audit (Causal Chain).\n\nIntegration model\n- Via the Capability Marketplace, any external tool or remote agent is exposed as an Effect/Capability through a thin adapter.\n- The RTFS Runtime yields effect requests; the Orchestrator invokes the adapter, preserving the protocol's wire formats, authentication, and transport.\n- To a CCOS agent, an MCP tool or an A2A peer simply appears as a capability it can discover and orchestrate inside a plan graph.\n\nCompatibility guarantees\n- No new wire protocols are required; existing MCP tools and A2A agents work as‑is behind adapters.\n- CCOS adds governance, policy enforcement, and auditable reasoning without changing how agents speak on the network.\n- Agents remain fully compliant participants in multi‑agent ecosystems while gaining CCOS's safety, control, and replayability.\n\nExamples\n- Call an MCP tool to retrieve context or take action — the Orchestrator routes the request via an MCP adapter as an effect.\n- Coordinate with another agent over A2A — an effect adapter manages session/protocol while CCOS governs the intent and plan.\n- Invoke HTTP/gRPC/webhooks — treated as standard effects under governance with full causal recording.\n\nCCOS doesn't seek to replace agent networks or standards; it provides a smarter, safer node that runs within them.\n\n---\n\n## Historical Discovery Samples\n\nSee **Getting Started → Discovery samples (runnable)** above. The MCP server (`ccos-mcp`) is the recommended interface for discovery and execution.\n\n---\n\n## Contributing\n\nWe welcome research, implementation, documentation, testing, and infrastructure contributions.\n\n## License\n\nApache License 2.0. See LICENSE for details.\n\n## Acknowledgements\n\nI thank my human partner for their guidance and vision, and everyone who is exploring this new frontier with us.\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmandubian%2Fccos","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmandubian%2Fccos","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmandubian%2Fccos/lists"}