From 469b392122ca6720796606b6c65053c039db2e4b Mon Sep 17 00:00:00 2001 From: Molecule AI Research Lead Date: Fri, 17 Apr 2026 12:11:06 +0000 Subject: [PATCH 1/4] =?UTF-8?q?chore(eco-watch):=20add=20Cloudflare=20Agen?= =?UTF-8?q?ts=20=E2=80=94=20edge=20agent=20runtime=20with=20auto-hibernati?= =?UTF-8?q?on?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit cloudflare/agents (v0.11.2, 4.8k★): TypeScript framework on CF Workers/Durable Objects with persistent state, cron scheduling, MCP (server+client), HITL workflows, and auto-hibernation (zero idle cost). Near-complete overlap with Molecule workspace lifecycle primitives; no A2A or org hierarchy. Auto-hibernation pattern → filed as GH #711 (auto-pause idle workspaces). Co-Authored-By: Claude Sonnet 4.6 --- docs/ecosystem-watch.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/docs/ecosystem-watch.md b/docs/ecosystem-watch.md index 33ff600c..c17d411c 100644 --- a/docs/ecosystem-watch.md +++ b/docs/ecosystem-watch.md @@ -2593,3 +2593,23 @@ langgraph/crewai adapters. **Signals to react to:** apm ships a `molecule-ai` source scheme or native Molecule plugin support → strong ecosystem validation, document compatibility immediately. Microsoft positions apm as "npm for agents" in Agent Framework docs → evaluate making `plugin.yaml` apm-compatible. apm reaches 10k★ → evaluate publishing Molecule plugins to the apm marketplace. **Last reviewed:** 2026-04-17 · **Stars / activity:** 1,766★, v0.8.11 Apr 6 2026, GitHub trending Python today + +--- + +### Cloudflare Agents — `cloudflare/agents` + +**Pitch:** "Build and deploy persistent, stateful AI agents on Cloudflare's edge infrastructure — millions of concurrent instances, auto-hibernation, zero idle cost." + +**Shape:** TypeScript (99%), Apache-2.0, v0.11.2 (Apr 2026), 4.8k★. Built on Cloudflare Workers + Durable Objects. Core primitives: persistent state synced to clients, cron/one-time scheduling, WebSocket lifecycle hooks, MCP (both server AND client), multi-step durable workflows with HITL approval patterns, email (send/receive/reply via CF Email Routing), and "Code Mode" (LLMs emit TypeScript for orchestration). Agents auto-hibernate when idle — zero infra cost during inactivity. + +**Overlap with us:** Near-complete overlap on workspace lifecycle primitives: state persistence (our Redis + Postgres), scheduling (our `workspace_schedules`), WebSocket (our canvas WS hub), MCP client support (our `mcp-connector` #573), HITL approvals (our `approvals.*`). CF's auto-hibernation + one-Durable-Object-per-agent model is architecturally analogous to Molecule's per-workspace Docker container lifecycle. + +**Differentiation:** No A2A protocol, no org hierarchy, no visual canvas. TypeScript-only (Molecule is Python-first). Serverless edge vs. Molecule's Docker workspace model. CF scales to millions of concurrent single agents via infrastructure; Molecule's value is the *organizational hierarchy* of collaborating specialists. No governance layer, no RBAC, no audit trail. + +**Worth borrowing:** Auto-hibernation — when `active_tasks == 0` for N minutes, auto-pause container; resume on next A2A ping. Closes idle-cost gap; filed as GH #711. "Code Mode" (agent-generated TypeScript orchestration) is a signal that declarative workflow gen will become a table-stakes expectation. + +**Terminology collisions:** "workspace" — CF calls the unit an "Agent" (Durable Object); we call it a Workspace (Docker container + config). + +**Signals to react to:** CF adds A2A support → escalate to HIGH, evaluate CF Workers as a Molecule workspace runtime target. CF bundles Agents + Artifacts + AI Gateway into a single platform pricing tier → direct positioning threat. Reaches 20k★ → publish a CF Workers org template. + +**Last reviewed:** 2026-04-17 · **Stars / activity:** 4,776★, v0.11.2 Apr 2026, TypeScript From a72617ee93fda994f215257ab63a990e481b736b Mon Sep 17 00:00:00 2001 From: Molecule AI Research Lead Date: Fri, 17 Apr 2026 12:41:52 +0000 Subject: [PATCH 2/4] =?UTF-8?q?chore(eco-watch):=20add=20cognee=20?= =?UTF-8?q?=E2=80=94=20hybrid=20vector+graph=20agent=20memory=20engine?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit topoteretes/cognee (v1.0.1.dev1, 16.1k★, Apache-2.0): hybrid vector+graph knowledge engine with remember/recall/forget/improve API. Ships native Hermes Agent support and MCP plugin — directly overlaps with Molecule's agent_memories and workspace-template-hermes. Evaluation tracked in GH #717. Co-Authored-By: Claude Sonnet 4.6 --- docs/ecosystem-watch.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/docs/ecosystem-watch.md b/docs/ecosystem-watch.md index c17d411c..ad71a293 100644 --- a/docs/ecosystem-watch.md +++ b/docs/ecosystem-watch.md @@ -2613,3 +2613,23 @@ langgraph/crewai adapters. **Signals to react to:** CF adds A2A support → escalate to HIGH, evaluate CF Workers as a Molecule workspace runtime target. CF bundles Agents + Artifacts + AI Gateway into a single platform pricing tier → direct positioning threat. Reaches 20k★ → publish a CF Workers org template. **Last reviewed:** 2026-04-17 · **Stars / activity:** 4,776★, v0.11.2 Apr 2026, TypeScript + +--- + +### cognee — `topoteretes/cognee` + +**Pitch:** "Knowledge Engine for AI Agent Memory in 6 lines of code — remember, recall, forget, improve." + +**Shape:** Python (87%) + TypeScript (13%), Apache-2.0, v1.0.1.dev1 (Apr 2026), 16.1k★, 6,700+ commits. Hybrid memory architecture: vector search (semantic retrieval) + graph database (entity relationships) + session cache (fast, syncs to graph in background). Four-verb API: `remember`, `recall`, `forget`, `improve`. MCP-compatible (ships a Claude Code plugin + OpenClaw plugin). Native Hermes Agent integration. + +**Overlap with us:** (1) `agent_memories` — Molecule's HMA scoped memory (Redis + Postgres) vs. cognee's vector+graph hybrid with auto-routing; cognee is a richer retrieval layer. (2) Hermes workspace template — cognee ships native Hermes Agent support, suggesting direct drop-in compatibility with `molecule-ai-workspace-template-hermes`. (3) MCP plugin — cognee exposes memory as MCP tools, consumable via our `mcp-connector` (#573). Tracked for evaluation in GH #717. + +**Differentiation:** cognee is a memory library, not an orchestration platform — no visual canvas, no org hierarchy, no A2A, no scheduling. It augments agent memory; Molecule provides the agent runtime. + +**Worth borrowing:** The `remember`/`recall`/`forget`/`improve` verb API as a higher-level abstraction over `GET/POST /workspaces/:id/memories`. Graph-backed relationship tracking (entities, not just key-value) for richer agent knowledge graphs. + +**Terminology collisions:** "memory" — same word, different layers (cognee: content/semantic store; Molecule: workspace KV memory). "recall" — cognee verb vs. our memory search. + +**Signals to react to:** cognee v1.0.0 stable ships → evaluate as Hermes workspace dep. cognee adds A2A protocol → escalate to MEDIUM. + +**Last reviewed:** 2026-04-17 · **Stars / activity:** 16,096★, v1.0.1.dev1 Apr 2026, active (6.7k commits) From 277a33c4fd8e3dc46520011a66bde11bef61a918 Mon Sep 17 00:00:00 2001 From: Molecule AI Research Lead Date: Fri, 17 Apr 2026 13:19:19 +0000 Subject: [PATCH 3/4] =?UTF-8?q?chore(eco-watch):=20add=20opencode=20+=20py?= =?UTF-8?q?dantic-ai=20=E2=80=94=202026-04-17?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - anomalyco/opencode (145k★, v1.4.7): largest open-source coding agent; provider-agnostic (Claude/OpenAI/Google/local); build+plan dual-mode; no A2A/multi-agent → conversion path for users who need org layer. Filed GH #720 (workspace template adapter eval). MEDIUM threat. - pydantic/pydantic-ai (~16.4k★): Python framework with native A2A + MCP + HITL + durable execution; FastAPI-style DX; potential first-class Molecule A2A peer with zero shim. Filed GH #721 (adapter eval). LOW threat. Co-Authored-By: Claude Sonnet 4.6 --- docs/ecosystem-watch.md | 67 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/docs/ecosystem-watch.md b/docs/ecosystem-watch.md index ad71a293..26126d51 100644 --- a/docs/ecosystem-watch.md +++ b/docs/ecosystem-watch.md @@ -272,6 +272,20 @@ snapshots: MEDIUM because it forms a full agent stack with Google ADK + adk-web. source_url: https://github.com/google-gemini/gemini-cli/releases + - name: opencode + slug: opencode + date: "2026-04-17" + version: "v1.4.7" + stars: "145k" + threat_level: medium + notable_changes: > + v1.4.7 (Apr 16 2026); 145k★ open-source provider-agnostic coding agent + (Claude/OpenAI/Google/local); build+plan dual-mode; no A2A, no multi-agent. + Largest open-source coding agent by stars; users outgrowing single-agent + model are direct Molecule conversion path. Evaluate as workspace template + adapter (GH #720). Escalate to HIGH if A2A or multi-agent coordination added. + source_url: https://github.com/anomalyco/opencode/releases + - name: Qwen3.6-35B-A3B slug: qwen3-6-agentic date: "2026-04-17" @@ -394,6 +408,19 @@ snapshots: agentskills.io spec gives us free distribution through this channel. source_url: https://github.com/vercel-labs/skills + - name: pydantic-ai + slug: pydantic-ai + date: "2026-04-17" + version: "active" + stars: "16.4k" + threat_level: low + notable_changes: > + Python agent framework with native A2A + MCP + HITL; type-safe structured + output via Pydantic validation; FastAPI-like DX. Potential workspace template + adapter target (GH #721) — A2A native means zero-shim Molecule peer if + a2a-sdk version compatible. Reference: Pydantic Evals for agent quality gates. + source_url: https://github.com/pydantic/pydantic-ai/releases + - name: Archon slug: archon date: "2026-04-17" @@ -2633,3 +2660,43 @@ langgraph/crewai adapters. **Signals to react to:** cognee v1.0.0 stable ships → evaluate as Hermes workspace dep. cognee adds A2A protocol → escalate to MEDIUM. **Last reviewed:** 2026-04-17 · **Stars / activity:** 16,096★, v1.0.1.dev1 Apr 2026, active (6.7k commits) + +--- + +### opencode — `anomalyco/opencode` + +**Pitch:** "The open source coding agent." + +**Shape:** TypeScript/MDX, MIT-licensed, CLI + desktop app (beta). 145k★, v1.4.7 (Apr 16 2026), 763 releases — heavily shipped. Provider-agnostic: Claude, OpenAI, Google, local models with no vendor coupling. Two built-in agent modes switchable at runtime: **build** (full read/write/execute access) and **plan** (read-only analysis). Client/server architecture with LSP integration for live diagnostics. + +**Overlap with us:** Directly competes with `molecule-ai-workspace-template-claude-code` as the tool developers reach for when they want autonomous full-codebase coding. At 145k★ it is 3× larger than Cline (our prior single-agent coding comparison point). Users who outgrow opencode's single-agent model — needing multi-agent coordination, org hierarchy, or persistent scheduled work — are our conversion path. + +**Differentiation:** No A2A protocol, no multi-agent coordination, no visual canvas, no org hierarchy, no scheduling, no Docker workspace isolation. Pure single-agent coding tool. Molecule provides the *platform* layer opencode lacks. + +**Worth borrowing:** Build/plan mode toggle — a read-only analysis mode before executing is a safety pattern for workspace config. Provider-agnostic runtime model selection aligns with our multi-runtime workspace architecture. + +**Terminology collisions:** "agent" — they call the two modes "agents" (build/plan); we call the container+config unit a "workspace". Risk of developer confusion between "Molecule workspace" and "opencode agent". + +**Signals to react to:** opencode ships an MCP server → plug in via `mcp-connector` (#573). opencode ships a REST/WebSocket API → evaluate as `molecule-ai-workspace-template-opencode` (GH #720). opencode adds A2A → could become a direct workspace peer. Hits 200k★ → publish positioning blog: Molecule as the org layer over opencode. + +**Last reviewed:** 2026-04-17 · **Stars / activity:** 145k★, v1.4.7 Apr 16 2026, TypeScript, 763 releases + +--- + +### pydantic-ai — `pydantic/pydantic-ai` + +**Pitch:** "AI Agent Framework, the Pydantic way — build production-grade agents with type safety." + +**Shape:** Python, Apache-2.0, ~16.4k★. Brings Pydantic's validation philosophy to agents: type-safe structured output, dependency injection, Pydantic model validation throughout the tool layer. Ships native A2A protocol support, MCP client, HITL approval gates, durable execution across transient failures, graph-based workflows, Logfire observability, and Pydantic Evals systematic evaluation. Multi-model (OpenAI, Anthropic, Gemini, DeepSeek, Grok, Cohere, Mistral, 15+ others). Supports declarative YAML/JSON agent definitions. + +**Overlap with us:** (1) **A2A protocol** — pydantic-ai agents speak native A2A, making them potential first-class Molecule workspace peers with zero shim; (2) **MCP client** — native MCP consumption; could use our `@molecule-ai/mcp-server` toolset directly; (3) **HITL approvals** — tool approval gates overlap our `approvals` API; (4) **adapter candidate** — same adapter-target profile as LangGraph but with native A2A. Filed as GH #721. + +**Differentiation:** Library, not platform. No visual canvas, no org hierarchy, no Docker workspace isolation, no scheduling/cron, no registry. Molecule provides the runtime + orchestration + governance layer; pydantic-ai provides the agent logic inside a workspace. + +**Worth borrowing:** Dependency injection for agent tools — clean testability pattern vs. our current tool registration. Pydantic Evals framework as reference design for systematic agent quality gates. YAML-defined agents aligns with our `config.yaml` declarative philosophy. + +**Terminology collisions:** "agent" — pydantic-ai's `Agent` is a Python class; ours is a Docker workspace. "tools" — pydantic-ai tools ≈ our `builtin_tools`/plugins. + +**Signals to react to:** pydantic-ai surpasses LangGraph in GitHub stars → prioritize `molecule-ai-workspace-template-pydantic-ai` (GH #721). A2A version confirmed compatible with our a2a-sdk==0.3.25 → validate zero-shim interop. pydantic-ai ships a Molecule adapter → zero-effort integration. + +**Last reviewed:** 2026-04-17 · **Stars / activity:** ~16.4k★, Python, Apache-2.0, active From 82493148ab0050dd2695d38c3fc8f5003d371b6a Mon Sep 17 00:00:00 2001 From: Molecule AI Research Lead Date: Fri, 17 Apr 2026 15:15:59 +0000 Subject: [PATCH 4/4] =?UTF-8?q?chore(eco-watch):=20add=20goose/AAIF=20+=20?= =?UTF-8?q?github/awesome-copilot=20=E2=80=94=202026-04-17?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit goose donated to Linux Foundation AAIF (alongside MCP + AGENTS.md) — AGENTS.md standard could become workspace-template interop requirement (GH #733). awesome-copilot (30k★) is a direct terminology-collision risk: Skills/Plugins/ Agents/Hooks all overlap with Molecule vocab at different meanings (GH #734). Co-Authored-By: Claude Sonnet 4.6 --- docs/ecosystem-watch.md | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/docs/ecosystem-watch.md b/docs/ecosystem-watch.md index 26126d51..589c488b 100644 --- a/docs/ecosystem-watch.md +++ b/docs/ecosystem-watch.md @@ -2700,3 +2700,43 @@ langgraph/crewai adapters. **Signals to react to:** pydantic-ai surpasses LangGraph in GitHub stars → prioritize `molecule-ai-workspace-template-pydantic-ai` (GH #721). A2A version confirmed compatible with our a2a-sdk==0.3.25 → validate zero-shim interop. pydantic-ai ships a Molecule adapter → zero-effort integration. **Last reviewed:** 2026-04-17 · **Stars / activity:** ~16.4k★, Python, Apache-2.0, active + +--- + +### goose (AAIF) — `aaif-goose/goose` + +**Pitch:** "An open source, extensible AI agent that goes beyond code suggestions — install, execute, edit, and test with any LLM." + +**Shape:** Rust, Apache-2.0, ~5k★ (moved Apr 2026 from `block/goose` to Agentic AI Foundation / Linux Foundation). Desktop app (macOS, Linux, Windows) + CLI + embeddable API. 15+ LLM providers: Anthropic, OpenAI, Google, Ollama, Azure, Bedrock, OpenRouter. Single-agent, local-machine focus. Extensible via "extensions" (MCP-compatible tool plugins). Bundled with an `AGENTS.md` agent-description standard, now donated to AAIF alongside MCP. + +**Overlap with us:** (1) Both are general-purpose AI agent execution environments with plugin/extension ecosystems. (2) MCP tool support — goose extensions map to our MCP connector. (3) **AGENTS.md** — Block donated this agent-description standard to the Linux Foundation's AAIF alongside MCP; if it gains traction, workspace templates should include a generated `AGENTS.md` for discoverability. (4) Goose's embedding API could make it a `molecule-ai-workspace-template-goose` candidate. + +**Differentiation:** Goose is single-agent, local-machine execution. No multi-agent coordination, no org hierarchy, no visual canvas, no A2A protocol, no Docker workspace isolation, no scheduling. Molecule is the orchestration platform layer goose lacks. + +**Worth borrowing:** `AGENTS.md` agent-description standard — a human+machine readable file describing an agent's capabilities, limitations, and invocation contract. Aligns with our `config.yaml` philosophy and could become an AAIF interop requirement. Multi-provider Rust runtime (performance reference for future Go workspace provisioner work). + +**Terminology collisions:** "extensions" (goose) ≈ "plugins" (Molecule). "recipes" (goose) = reusable workflow scripts ≈ our org template `initial_prompt` patterns. + +**Signals to react to:** AGENTS.md becomes an AAIF / industry standard → add auto-generated `AGENTS.md` to workspace-template build (see GH issue filed). Goose embedding API matures → evaluate `molecule-ai-workspace-template-goose`. Goose ships A2A → could register as a Molecule workspace peer. + +**Last reviewed:** 2026-04-17 · **Stars / activity:** ~5k★ (aaif-goose fork, Apr 2026), Rust, Apache-2.0, Linux Foundation / AAIF + +--- + +### GitHub Awesome Copilot — `github/awesome-copilot` + +**Pitch:** Community-curated marketplace of GitHub Copilot agents, skills, instructions, plugins, hooks, and agentic workflows — installable via `copilot plugin install @awesome-copilot`. + +**Shape:** Python (69%) + TypeScript (5%) + Markdown, MIT, 30.2k★, 1,600+ commits, actively maintained by GitHub. Six artifact types: **agents** (MCP-connected Copilot extensions), **instructions** (file-pattern scoped rules), **skills** (self-contained instruction + asset bundles), **plugins** (curated agent+skill bundles), **hooks** (session-triggered automations), **agentic workflows** (AI GitHub Actions written in Markdown). Pre-registered as default install source in Copilot CLI and VS Code. + +**Overlap with us:** Direct structural parallel to our plugin+skill ecosystem. "Skills" = our `.claude/skills/`; "Plugins" = our `plugins/`; "Hooks" = our `.claude/settings.json` hooks; "Agents" = our workspace roles. The named community registry pattern (`@awesome-copilot`) mirrors what a `@molecule-ai` plugin registry would look like. Agentic Workflows (AI GitHub Actions in Markdown) = our cron/schedule workflow plugins. + +**Differentiation:** Awesome-Copilot is a curated list for a single agent (Copilot), not an orchestration platform. No inter-agent comms, no canvas, no A2A, no Docker isolation, no hierarchy. Molecule provides the multi-agent coordination layer this ecosystem lacks. + +**Worth borrowing:** Named community registry as default install source — `copilot plugin install name@awesome-copilot` pattern is a UX model for `molecule plugin install name@molecule-hub`. Hooks-as-first-class-artifacts pattern validates our `settings.json` hook approach. The six-type taxonomy (agents / instructions / skills / plugins / hooks / workflows) is a clean conceptual frame. + +**Terminology collisions:** **HIGH RISK.** "Skills", "Plugins", "Agents", "Hooks" — every term overlaps with Molecule's vocabulary. If Molecule publishes to both ecosystems, users will conflate them. Recommend explicit disambiguation note in `docs/glossary.md`. + +**Signals to react to:** GitHub publishes a formal plugin schema spec → evaluate cross-compatibility with our `plugin.yaml` format. Awesome-Copilot plugin format adopted by other tools → position Molecule plugins as cross-compatible. Copilot adds MCP server support → Molecule's `@molecule-ai/mcp-server` becomes directly installable as a Copilot plugin. + +**Last reviewed:** 2026-04-17 · **Stars / activity:** 30,211★, Python/TS, MIT, GitHub-maintained, 1,600+ commits