Project_Velocity/.Agent Context/Tech/Tools Understanding.md

JackChen-me/open-multi-agent

https://github.com/JackChen-me/open-multi-agent

JackChen-me/open-multi-agent is a TypeScript-native framework inspired by Claude Code that utilizes a "goal-to-result" approach, dynamically decomposing user goals into a Task DAG (Directed Acyclic Graph) for execution via a runTeam() function. It features parallel task scheduling, multi-model support, Model Context Protocol (MCP) integration, and built-in action tools for file manipulation.

by Jack Chen is a lightweight, TypeScript-native multi-agent orchestration framework designed to enable goal-driven AI workflows where a team of specialized agents works collaboratively. It focuses on simplifying the process from a high-level goal to a finalized result without requiring manual DAG (Directed Acyclic Graph) wiring, often achieved through a single call.

First Principles and Core Workflow

The framework operates based on a few foundational principles aimed at simplicity and speed:

• Goal-Driven Orchestration: Rather than explicitly defining a fixed graph of nodes and edges (like LangGraph), the user provides a high-level objective (e.g., "Build a REST API"). A Coordinator Agent (an LLM) analyzes this goal at runtime to decompose it into a task Directed Acyclic Graph (DAG).
• Decoupled & Parallel Execution: The framework resolves dependencies between tasks and automatically executes independent tasks in parallel, maximizing speed.
• Shared Memory/Message Bus: Agents collaborate by sharing a common memory and message bus, allowing them to view each other's outputs and build upon prior work.
• TypeScript-Native: It is designed for Node.js, requiring only three main dependencies (@anthropic-ai/sdk, openai, zod), thus avoiding Python subprocess bridges.

Key Features

• Call: This feature initiates complex multi-agent workflows with a single line of code.
• Multi-Model Teams: Agents in the same team can use different providers, like Claude, GPT, Gemini, or local models via Ollama/vLLM, for task optimization.
• Structured Output (Zod): Supports using Zod validation. This ensures agent outputs are structured as JSON and enables auto-retries on validation failures.
• Built-in Tools: Includes ready-to-use tools for coding tasks such as (shell command execution), , , , and .
• Human-in-the-Loop: An optional callback in allows pausing execution to request human input before continuing.
• Lifecycle Hooks & Loop Detection: Includes / hooks for customizing input/output and loop detection to terminate agents repeating actions.
• Observability: Provides an callback to emit structured spans for tracing LLM calls, tool execution, and task timing with zero overhead when disabled.

Architectural Components

1. Coordinator Agent: This agent is responsible for task decomposition and assignment.
2. Task Queue: This component manages task dependencies and parallel execution.
3. Shared Memory: This shared context allows agents to read output from prior tasks. It is dependency-scoped by default to prevent context leakage.

Comparison with Other Frameworks

• vs. LangGraph JS: LangGraph is better for fixed, manual, and highly controlled graph workflows. is better for faster, dynamic, goal-driven iteration with less typing.
• vs. CrewAI: CrewAI is Python-focused, while is native to TypeScript/Node.js.
• vs. Vercel AI SDK: Vercel AI SDK handles single LLM calls, while uses it as a layer beneath for multi-agent coordination.

The framework is licensed under MIT and is a lightweight alternative for TypeScript-based AI automation.

Nemo Claw

NVIDIA NeMoClaw (introduced at GTC March 2026) is an open-source security, privacy, and governance stack designed to wrap OpenClaw autonomous AI agents. While OpenClaw enables AI agents to read emails, write code, and act autonomously, NeMoClaw fixes the critical security vulnerabilities—such as prompt injection, unauthorized network access, and data leaks—by placing agents into a "hardened, controlled sandbox".

First Principles: How NemoClaw Works

NemoClaw moves the security control point outside the agent itself, ensuring that even if an agent is compromised, it cannot override its own restrictions.

• 1. Infrastructural Isolation (OpenShell Runtime): NemoClaw leverages the NVIDIA OpenShell runtime to create an OS-level sandbox (using Landlock, seccomp, and network namespaces). The agent operates inside a restricted container, locked from accessing host resources directly.
• 2. Blueprint-Driven Deployment: NemoClaw uses a Blueprint—a versioned Python artifact (blueprint.yaml)—to create the sandbox. This blueprint defines the network policies, filesystem restrictions, and inference routes before the agent starts.
• 3. External Policy Enforcement: Security rules are applied at the infrastructure layer (gateway level), not within the agent’s prompt. If an agent tries to reach an unauthorized URL or write to an unlisted folder, the OpenShell gateway blocks it, regardless of the agent's "intent".
• 4. Privacy Routing (Inference Control): NemoClaw intercepts all inference requests (LLM API calls). The Privacy Router classifies queries by data sensitivity: high-sensitivity queries are routed locally to NVIDIA Nemotron models, while low-sensitivity queries are routed through secured cloud APIs.

Core Architecture Components

1. TypeScript CLI Plugin (nemoclaw): Handles user interaction, onboarding, and validation.
2. Blueprint (Python Artifact): Orchestrates sandbox creation, filesystem mapping, and security policy installation.
3. OpenShell Runtime: A secure runtime environment that enforces network and file policies at runtime.

Key Features and Capabilities

NemoClaw introduces several enterprise-grade features designed to solve the agent "trust trilemma" (Safety vs. Capability vs. Autonomy):

• OS-Level Agent Sandboxing: Restricts agent filesystem access to and , preventing access to the host file system.
• Network Egress Control: Blocks all unauthorized outbound connections, allowing only approved endpoints for API calls.
• Intent Verification: Analyzes proposed actions against operator-defined policies before the agent executes tool calls, preventing malicious actions.
• Local & Cloud Inference Support: Natively supports NVIDIA Nemotron models via NVIDIA Inference Microservices (NIM) for local, private AI, or routes to cloud frontier models.
• Live Policy Updates: Allows operators to update network and inference rules on-the-fly, without restarting the sandbox.
• Human-in-the-Loop Operator Approval: When an agent attempts an unauthorized action, the request surfaces in a Terminal User Interface (TUI) for human approval.
• Audit Logging: Generates structured, compliance-friendly logs of all significant agentic actions, including tool calls and model queries.
• NeMo Guardrails Integration: Uses defined configuration rules to enforce topical constraints, ensuring agents stay within their required domain.