Runx is an Apache-2.0 open source runtime built primarily in Rust that executes "agent skill workflows" by treating skills as portable operating manuals (`SKILL.md` files) and composing them into verifiable graphs. It positions itself not as an orchestration framework or vector store, but as a governance layer beneath agents that admits actions under explicit authority, manages credentials without exposing them to prompts, and seals execution results into verifiable receipts. The system enforces strict boundaries where authority narrows through the execution chain, ensuring that deterministic operations, process tools, and agent steps operate within tightly scoped grants.
- The core execution invariant follows a strict pipeline: admit, resolve grant, deliver credentials, execute, and seal.
- Skills are defined by a `SKILL.md` for human-readable knowledge and an optional `run.yaml` for machine-checkable execution contracts and step definitions.
- Credentials are bound to specific environment variables via "connectors," ensuring that the runtime delivers secrets to operations without ever copying them into skill contexts or receipts.
- The project includes a hosted catalog at runx.ai for publishing skills and verifying receipt provenance, though the local CLI can operate independently of any hosted services.
- Recent development focuses on a "hard cutover" to a unified architecture with five distinct step kinds (agent, operation, tool, ask, skill) and a consolidated run record system.
- The core execution invariant follows a strict pipeline: admit, resolve grant, deliver credentials, execute, and seal.
- Skills are defined by a `SKILL.md` for human-readable knowledge and an optional `run.yaml` for machine-checkable execution contracts and step definitions.
- Credentials are bound to specific environment variables via "connectors," ensuring that the runtime delivers secrets to operations without ever copying them into skill contexts or receipts.
- The project includes a hosted catalog at runx.ai for publishing skills and verifying receipt provenance, though the local CLI can operate independently of any hosted services.
- Recent development focuses on a "hard cutover" to a unified architecture with five distinct step kinds (agent, operation, tool, ask, skill) and a consolidated run record system.
ShenSeanChen writes about waku-agent, a local-first LLM agent harness built as an open-source Python package that lets users own the entire loop, memory, and eval pipeline in readable code. The project pairs a ~95-line reasoning loop with a SQLite-backed memory schema, a retrieval gate, and a release gate backed by deterministic tests and LLM-as-judge, and it ships a local dashboard for watching every message flow. Core `waku/` code is MIT-licensed and installable from PyPI, while the hosted platform lives in `hosted/` under Elastic License 2.0 so nobody can resell it as a managed service.
- The author is also building the commercial startup AutoManus.io, a sales-lead manager for made-to-order products, and AutoManus Technologies holds the Waku brand and design system under a separate brand license.
- Waku Memory is a hosted memory service at waku.one that the agent can share with Claude Code, Codex, Grok Bot, and Hermes through MCP.
- The repo includes a `treg` connector for pulling live research data from a personal treg account during agent turns.
- The `lab/` directory holds the video experiments comparing Waku against other agent harnesses and models, including Grok Bot and Meta's Muse agent.
- Recent commits add a trim step that shortens long already-read tool results to keep token spend down, and a final-answer pass that answers from what a turn already gathered when it hits the iteration limit.
- The author is also building the commercial startup AutoManus.io, a sales-lead manager for made-to-order products, and AutoManus Technologies holds the Waku brand and design system under a separate brand license.
- Waku Memory is a hosted memory service at waku.one that the agent can share with Claude Code, Codex, Grok Bot, and Hermes through MCP.
- The repo includes a `treg` connector for pulling live research data from a personal treg account during agent turns.
- The `lab/` directory holds the video experiments comparing Waku against other agent harnesses and models, including Grok Bot and Meta's Muse agent.
- Recent commits add a trim step that shortens long already-read tool results to keep token spend down, and a final-answer pass that answers from what a turn already gathered when it hits the iteration limit.
SandBase Harness is an open-source Node.js runtime that keeps agent sessions, sandboxed tools, memory, credentials, audit trails, and a web Console entirely on the user's own machine. An `init` command scaffolds a workspace with a `config.yaml` pointing to a provider environment variable, and `start` serves both an API and a dashboard on localhost. It supports OpenAI, Anthropic, MiniMax, or any OpenAI-compatible endpoint, and Docker is optional, used only for Docker-backed sandboxes. A CLI `chat` command is available for terminal-based interaction.
- Tool approval is a first-class concept; by default tool calls park for human approval, though `--tool-approval allow` can preauthorize them.
- The model ID must match what the provider actually serves (e.g., `deepseek-chat` for DeepSeek), or the turn fails with `model_not_found`.
- Provider settings saved via the Console only take effect after a restart, a gotcha the documentation calls out explicitly.
- The project is listed in the Official MCP Registry.
- Tool approval is a first-class concept; by default tool calls park for human approval, though `--tool-approval allow` can preauthorize them.
- The model ID must match what the provider actually serves (e.g., `deepseek-chat` for DeepSeek), or the turn fails with `model_not_found`.
- Provider settings saved via the Console only take effect after a restart, a gotcha the documentation calls out explicitly.
- The project is listed in the Official MCP Registry.
Leela Kumili writes about DoorDash's multi-agent LLM system that automates stale feature flag cleanup across 623 repositories. In an evaluation of 50 stale flags, the system produced usable pull requests for 45, averaging 13.8 minutes and $4.79 per cleanup versus an estimated one to two hours for manual work. The two-phase workflow uses Claude Sonnet as an orchestrator to retrieve Jira tickets and query experimentation metadata via MCP, then Claude Opus agents in isolated Git worktrees to perform code changes and validation.
- A single Boolean flag can require changes across 5–20 files due to dependency-injected wrappers
- Uber's AST-based Piranha couldn't handle DoorDash's DI patterns where flag-to-logic relationships are semantic
- Outcomes: 31 first-pass merges, 14 revisions, 5 engineer interventions, zero regressions
- Gradle runs without its daemon to prevent state sharing between concurrent worktrees
- Work accepted for the ICSME 2026 industry track
- A single Boolean flag can require changes across 5–20 files due to dependency-injected wrappers
- Uber's AST-based Piranha couldn't handle DoorDash's DI patterns where flag-to-logic relationships are semantic
- Outcomes: 31 first-pass merges, 14 revisions, 5 engineer interventions, zero regressions
- Gradle runs without its daemon to prevent state sharing between concurrent worktrees
- Work accepted for the ICSME 2026 industry track
@omarsar0 writes on X that the fastest path to genuinely understanding agent harnesses is to build one from scratch in TypeScript or Python, starting with a minimal ReAct implementation prompted from Google's original paper, targeting three clean components—an LLM inference module (multi-model, OpenRouter-backed, with separable system prompt), an MCP tools module for interoperability, and a simple agent loop that ties them together—then logging every input/output at each boundary and iterating against a small set of diverse test tasks so each change is inspectable. The punchline: skip the framework first, because only once you've felt the loop, the tokens, and the tool calls in your own code do the "next steps"—memory, skills, subagents—stop being black boxes you configure and become modules you actually know how to tune.
- LLM module: wraps inference across multiple frontier models via OpenRouter; system prompt either embedded or isolated for context-engineering experiments
- Tools module: implement as MCP (Model Context Protocol) tools for cross-harness interoperability, or as bespoke functions if experienced
- Agent loop: ReAct pattern (alternating reasoning traces and action calls) encapsulating both LLM and tools; exit conditions handled via system-prompt instructions (non-deterministic), code-level checks (deterministic), or both
- Logging strategy: capture loop in/out, every LLM call in/out, and every tool-call in/out; run a fixed diverse task suite after each modification
- Scaling path: keep architecture modular so memory, skills, and subagent orchestration can be bolted on once the core loop is understood
- Shortcut alternatives (if not building from scratch): Pi SDK or LangChain harness tooling
- LLM module: wraps inference across multiple frontier models via OpenRouter; system prompt either embedded or isolated for context-engineering experiments
- Tools module: implement as MCP (Model Context Protocol) tools for cross-harness interoperability, or as bespoke functions if experienced
- Agent loop: ReAct pattern (alternating reasoning traces and action calls) encapsulating both LLM and tools; exit conditions handled via system-prompt instructions (non-deterministic), code-level checks (deterministic), or both
- Logging strategy: capture loop in/out, every LLM call in/out, and every tool-call in/out; run a fixed diverse task suite after each modification
- Scaling path: keep architecture modular so memory, skills, and subagent orchestration can be bolted on once the core loop is understood
- Shortcut alternatives (if not building from scratch): Pi SDK or LangChain harness tooling
Michal Sutter writes that the Qwen Developer team has released zg (zvec-grep), an open-source local-first search layer designed to streamline how coding agents find information within a workspace. By unifying semantic search, BM25, and ripgrep under a single interface, it reduces tool calls and token usage for LLM agents that would otherwise struggle with manual context assembly or imprecise keyword matching.
- The package is available via npm as `@zvec/zvec-grep` under an Apache 2.0 license.
- It supports four retrieval routes: a hybrid default, BM25 (`--fts`), vector similarity (`--vector`), and literal/regex matching (`--rg`).
- An MCP (Model Context Protocol) integration allows seamless use with tools like Claude Code, Cursor, and Codex.
- Embeddings run locally by default using models such as `potion-code-16m-v2`, though remote Qwen endpoints are also supported via explicit authorization.
- Benchmarks suggest zg can cut tool calls and input tokens for coding agents by approximately 40% to 50%.
- The package is available via npm as `@zvec/zvec-grep` under an Apache 2.0 license.
- It supports four retrieval routes: a hybrid default, BM25 (`--fts`), vector similarity (`--vector`), and literal/regex matching (`--rg`).
- An MCP (Model Context Protocol) integration allows seamless use with tools like Claude Code, Cursor, and Codex.
- Embeddings run locally by default using models such as `potion-code-16m-v2`, though remote Qwen endpoints are also supported via explicit authorization.
- Benchmarks suggest zg can cut tool calls and input tokens for coding agents by approximately 40% to 50%.
Leela Kumili writes about DoorDash's Flux platform, which moved LLM-based coding agent workloads from developer laptops to cloud infrastructure, automating 130,000 engineering tasks in a single month and supporting over 25,000 automated code reviews per week. The platform was built after local execution hit limits on power, uptime, and security, and is organized around four primitives: Firecracker microVM sandboxes, an in-house MCP gateway, YAML-defined playbooks, and multiple invocation surfaces (Slack, GitHub, cron, CLI, conversational interfaces).
- Sandboxes achieve a 95th percentile SLO under 5 seconds for full setup, including microVM start, repo clone, build tool install, and agent harness configuration.
- Playbooks can mix agent-driven steps with deterministic code where predictable execution or validation is required.
- The Agent Gateway enforces scoped permissions and logs all agent activity for auditing and policy enforcement.
- DoorDash switched Slack integration from private channels to public threads so engineers could observe agent executions and see how other teams delegated work.
- Sandboxes achieve a 95th percentile SLO under 5 seconds for full setup, including microVM start, repo clone, build tool install, and agent harness configuration.
- Playbooks can mix agent-driven steps with deterministic code where predictable execution or validation is required.
- The Agent Gateway enforces scoped permissions and logs all agent activity for auditing and policy enforcement.
- DoorDash switched Slack integration from private channels to public threads so engineers could observe agent executions and see how other teams delegated work.
Yan Xie, Virat Patel and Albert Chang write that traditional developer-centric APIs are often too granular to support autonomous agents effectively, frequently leading to high latency and increased failure rates during complex workflows. Webflow is transitioning toward intent-driven architectures through the Model Context Protocol (MCP), replacing multi-step chains of low-level API calls with streamlined task-oriented tools that allow LLMs to operate more reliably via declarative commands.
- Use Cloudflare Durable Objects to manage stateful execution for long-running agent sessions.
- Prioritize observability focused on model reasoning and intent rather than traditional infrastructure telemetry.
- Implement layered tool architectures to prevent "tool explosion" as product capabilities expand.
- Use Cloudflare Durable Objects to manage stateful execution for long-running agent sessions.
- Prioritize observability focused on model reasoning and intent rather than traditional infrastructure telemetry.
- Implement layered tool architectures to prevent "tool explosion" as product capabilities expand.
Nolen Jonker writes about how he transitioned from using Claude Code to running local LLMs equipped with filesystem access via the Model Context Protocol (MCP) for administrative tasks. He notes that while Claude is superior for complex coding, a local model can handle folder organization and file management without the privacy concerns of sending sensitive data to cloud servers or being subject to rate limits.
- The filesystem MCP server is an official Anthropic-maintained Node.js package available via npm.
- Setting up the tool in LM Studio requires only a single edit to a `mcp.json` file.
- Running Qwen 3.5 9B on 8GB of VRAM provides sufficient capability for reliable multi-step sequences and tool calling.
- The filesystem MCP server is an official Anthropic-maintained Node.js package available via npm.
- Setting up the tool in LM Studio requires only a single edit to a `mcp.json` file.
- Running Qwen 3.5 9B on 8GB of VRAM provides sufficient capability for reliable multi-step sequences and tool calling.
This article explores how to integrate local Large Language Models (LLMs) with Docker environments using the Model Context Protocol (MCP). By setting up an MCP server, users can enable LLMs to execute container management tasks such as monitoring health, listing volumes, and deploying new services through natural language prompts. The author demonstrates how a high-end MoE model can handle complex instructions, even troubleshooting configuration errors autonomously.
Main points:
- Model Context Protocol (MCP) functions as a bridge between LLMs and external tools.
- Implementation details for the mcp-server-docker package.
- Hardware and model specifications (Qwen3.6-35B-A3B on RTX 3080 Ti).
- Examples of automated deployments for n8n and BentoPDF.
- Security measures for restricting dangerous LLM actions.
Main points:
- Model Context Protocol (MCP) functions as a bridge between LLMs and external tools.
- Implementation details for the mcp-server-docker package.
- Hardware and model specifications (Qwen3.6-35B-A3B on RTX 3080 Ti).
- Examples of automated deployments for n8n and BentoPDF.
- Security measures for restricting dangerous LLM actions.
