Yao App Runtime
A single-binary runtime for building controlled AI agents and web applications.
Per-dimension scores and reasoning
Evidence shows sandbox isolation (CLI Agent container) and Hook mechanism, but least privilege principle is not explicit; user confirmation mechanism not seen; data flow transparency partially shown (Hook pipeline), but data flow details not elaborated; sensitive data handling measures not explicit; many dependencies with recent versions, but no security audit; external effects (e.g., network calls) not explicitly restricted; rollback mechanism not seen; source attribution: publisher unverified, but copyright notice present. Deductions: lack of specific security design docs and implementation details.
Self-consistency: README and code structure mostly consistent, but local replace directives (go.mod) may cause build inconsistency; dependency availability: many dependencies, but no version pinning or mirror; failure messages: test workflows have error handling, but product's error messages not detailed. Deductions: local replace and dependency management may affect reproducible builds.
Audience and scenarios: clearly targets developers, provides multiple modes; capability boundaries: defined via Hooks and sandbox, but not detailed; trigger precision: Hook mechanism provides precise control, but docs not deep; environment fit: supports multiple platforms, but relies on external components like Docker. Deductions: docs insufficient on boundaries and trigger details.
Information architecture: README clear, but lacks detailed docs links; install notes: build and test workflows present, but user install guide missing; naming stability: project name stable, but version number not explicit; examples and FAQ: test examples present, but FAQ missing; known limitations: not mentioned; license: custom Apache 2.0 modification, but compliance not explicit; versioning and changelog: not provided; maintenance responsibility: CI and contributor agreement present, but publisher unverified. Deductions: missing version management and known limitations docs.
Output usability: provides REST APIs and UI, output formats clear; marginal value: provides multiple integrations (MCP, multi-agent), high value; cost-benefit: single binary deployment reduces ops cost, but commercial license may increase cost. Deductions: commercial license terms may restrict some users.
Claim traceability: feature claims in README have code and test support, but some unverified; cross-source corroboration: CI tests present, but not independently verified; fact-inference separation: docs distinguish feature descriptions and design philosophy, but not explicitly labeled. Deductions: static review cannot verify actual runtime behavior.
- Publisher identity unverified; assess supply chain risk carefully.
- License is a custom modification; commercial use requires attention to terms.
- Local replace directives in go.mod may cause build inconsistencies.
- Many dependencies without security audit; watch for known vulnerabilities.
What does this agent do, and when should you use it?
Yao is an open-source runtime for building AI agents and web applications, delivered as a single binary. Each request follows a Create Hook, executor, and Next Hook pipeline: hooks can inject context and constraints before execution, then validate output or continue a workflow afterward. The executor can use LLM providers such as OpenAI and Anthropic, run CLI agents including OpenCode, Claude Code, and Codex in an isolated container, or execute custom TypeScript only. The runtime also includes data models, REST APIs, server-rendered SUI pages, a CUI chat interface, a V8 TypeScript engine, and vector, graph, and GraphRAG search. It targets ARM64/x64, and the README states that the host does not require Python, Node.js, or containers.
A request enters a Create Hook, where it can receive context, constraints, or routing; an LLM, CLI Agent, or pure TypeScript executor then handles it; a Next Hook can validate the result, trigger downstream work, or drive another step. LLM mode can call OpenAI, Anthropic, and other providers. CLI Agent mode can run OpenCode, Claude Code, or Codex in an isolated container with VNC desktop support, while Pure Hook mode runs custom TypeScript. Yao connects MCP tools over process, SSE, or STDIO transport, exposes Memory API scopes for request, session, user, and team, and can serve REST APIs, SUI pages, and a CUI chat interface. Its search features include vector search using OpenAI or FastEmbed, a knowledge graph, and hybrid GraphRAG.
- An internal-tools team that wants data models, REST APIs, SUI pages, and a chat interface in one executable runtime.
- A team building a support or knowledge assistant that needs
Create Hookcontext injection andNext Hookoutput validation or follow-on actions. - An engineering team that needs Codex, Claude Code, or OpenCode to perform work inside an isolated CLI Agent container with VNC support.
- A product team with existing TypeScript business rules that needs deterministic routing or menu flows through Pure Hook mode without invoking AI.
- An application team that needs both embedding-based retrieval and entity-relationship retrieval through vector search, knowledge graphs, and GraphRAG.
What are this agent's strengths and limitations?
- A single request pipeline combines
Create Hook, an executor, andNext Hook, allowing pre-execution constraints and post-execution validation or orchestration. - One Hook interface can mix LLMs, containerized CLI agents, and pure TypeScript executors, combining deterministic logic with model-driven flows.
- The runtime brings together data models, REST APIs, SUI, CUI, V8 TypeScript, and retrieval features instead of requiring those pieces to be assembled separately.
- It natively supports process, SSE, and STDIO MCP transports and exposes Memory API scopes for request, session, user, and team.
- The material does not provide binary retrieval, startup commands, configuration examples, or a minimal project, so the initial deployment path cannot be reproduced from it.
- LLM mode depends on external providers such as OpenAI and Anthropic; credential setup, costs, model selection, and failure behavior are not documented.
- CLI Agent mode uses an isolated container and may expose a VNC desktop, adding operational and security assessment work for teams adopting that mode.
- Although the host is said not to need Python, Node.js, or containers, the supplied material does not define the file layout or release workflow for TypeScript Hooks, SUI, data models, and APIs.
How do you install or deploy this agent?
The supplied material provides no copyable download, installation, initialization, or start command. It only establishes that Yao is distributed as a single binary for ARM64/x64 and that the host does not need Python, Node.js, or containers. A reproducible installation still lacks the binary acquisition location, platform-specific filename, configuration format, start command, and first-application creation steps.
How do you use this agent?
The supplied material contains no copyable configuration, CLI invocation, or minimal runnable example, so a verified first invocation cannot be provided. The documented operating model is to define Create Hook and Next Hook behavior and choose an LLM, CLI Agent, or Pure Hook executor; MCP tools may be connected through process, SSE, or STDIO transport. When using OpenAI, Anthropic, or other LLM providers, the required credential names and configuration method are not documented in the supplied material.
How does this agent compare with similar options?
Yao treats OpenAI and Anthropic as LLM executors and can run OpenCode, Claude Code, or Codex in a container. In the supplied material, those products are integration options rather than like-for-like Yao alternatives.
FAQ
Is Yao tied to one model provider?
Can it incorporate Codex or Claude Code?
Must the deployment host install Node.js, Python, or containers?
What credentials are needed for model and tool connections?
What happens if execution or hook validation fails?
Next Hook is documented as able to validate output and trigger downstream work, but no error-handling, retry, or recovery policy is specified.