The One 0.1.0 Release Notes

The One 0.1.0 is our first desktop release, and the first complete expression of the product’s core idea: users should not have to keep writing glue code just to explore Multi-Agent architectures. Instead, they should be able to build, run, observe, and iterate on their own multi-agent systems directly inside a desktop application.

This is not another single-Agent chat window. The One was designed for Multi-Agents from day one.

Core Idea

Multi-Agent systems are the future of AI Agents, but most exploration today is still stuck at the stage of “manually wiring a few Agents together” and hard-coding a handful of interaction paths. That process is slow, fragile, hard to reuse, and makes it difficult to see what is actually happening between Agents.

The goal of The One is straightforward: to let people build any Multi-Agent architecture they can imagine using a single piece of software.

What’s New

Multi-Agent Repository System

0.1.0 introduces a resource repository interface designed specifically for Multi-Agent architectures:

• Agent Preset: define each Agent’s identity, model, prompts, Profiles, Skills, and tool capabilities.
• Profile / Skill: maintain long-form prompts, reusable capability instructions, and context modules independently, then mount them onto different Agents as needed.
• Tool / MCP: configure built-in tools or external MCP tools for Agents, so capabilities can be composed instead of hard-coded.
• Graph Blueprint: build Multi-Agent Graphs with nodes and edges, defining collaboration relationships and communication paths between Agents.

You can refine your Agents first, then assemble the Graph. That order matters: a strong Multi-Agent system is not just “a pile of models,” but a clear design of roles, capability boundaries, and collaboration protocols.

Visual Graph Blueprint Editor

The One 0.1.0 supports creating and editing Multi-Agent Graphs through a visual canvas:

• Add Agent nodes to the canvas.
• Bind different Agent Presets to each node.
• Connect Agents with edges to represent collaboration, handoff, feedback, or review relationships.
• Add node-specific context, allowing the same Agent Preset to play different roles in different Graphs.
• Create, rename, delete, and save Workflow Blueprints.

This turns Multi-Agent architecture from a process hidden in code into a system design that can be seen, discussed, and modified.

Local Project Workspace Execution

0.1.0 supports launching Workflows inside a specified local project path, allowing your Multi-Agent Graphs to actually start working.

You can choose a project directory, create a Workflow run, and let the Agent network you designed collaborate around that workspace. The experience feels close to local desktop Agent applications, but with one key difference: you are not running a fixed Agent. You are running a Multi-Agent Graph that you created yourself.

Transparent Runtime Observation

The One is explicitly against black-box Agent execution.

In 0.1.0, you can observe a Graph run from a “god’s-eye view”:

• View the current Workflow execution chain.
• Inspect the list and status of running Agents.
• Open the message history of an individual Agent.
• Inspect an Agent’s context composition.
• View available tools and tool-call records.
• Inspect shared data and runtime snapshots.
• View sub-Workflows, Task Boards, task layers, and task results.

This transparency is not decorative. It is infrastructure for Multi-Agent exploration. If you cannot see how Agents collaborate, you cannot systematically improve the architecture.

Task Board Collaboration for Complex Work

0.1.0 introduces Task Board capabilities for decomposing complex work.

Agents can split work into layered task boards: tasks within the same layer can run in parallel, while later layers can wait for earlier results before proceeding. During execution, the system can create Worker / Reviewer-style collaboration structures, so complex tasks are no longer handled by a single Agent from start to finish.

This means The One is not just “connecting a few Agents.” It is beginning to support genuinely organized, multi-role, multi-stage collaboration.

Dynamic Graph Capabilities

The One 0.1.0 already includes the foundation for dynamic runtime collaboration:

• Agents can wake other nodes.
• Agents can put themselves or other nodes into a waiting state.
• Agents can complete a Workflow.
• Agents can read Workflow node status.
• Agents can extend collaboration relationships during execution.

This means a Graph does not have to remain a static flowchart forever. As a task progresses, Agents can adjust the collaboration structure based on the situation. This is one of the key directions that separates The One from traditional workflow tools.

Human-in-the-Loop Interaction

0.1.0 allows Agents to request human input when needed, including:

• Questions
• Confirmations
• Choices
• Sending additional context to a specific Agent
• Keeping runtime state observable while waiting for a human response

This prevents Agents from getting stuck on uncertain decisions, and lets humans intervene at key moments instead of merely watching from beginning to end.

Models, Language, and Desktop Experience

0.1.0 also includes the foundational experience expected from a complete desktop application:

• Chinese / English interface switching.
• Account login status display.
• Model selection and model catalog support.
• Desktop update checking and installation.
• Diagnostic package export.
• Local backend runtime restart.
• Local management of projects, Workflows, and run history.

Built-In Starting Points

0.1.0 includes a basic set of Agents and Workflows to help users get started quickly:

• Manager: responsible for human communication and Workflow management.
• Architect: responsible for architecture design, task decomposition, and review.
• Developer: responsible for coding and execution.
• Tool Tester: used for validating tool capabilities.
• Simple Dev Workflow: a basic development collaboration Graph.

These are not final answers. They are starting points. The point of The One is not to make everyone use the same Agents, but to let everyone build their own Multi-Agent architecture.

Known Boundaries

0.1.0 is an initial release focused on validating the product’s core loop: repository, assembly, execution, observation, and dynamic collaboration.

This version is best suited for developers, researchers, and advanced users who are willing to explore Multi-Agent architectures. Some advanced capabilities, especially runtime Graph expansion, layered Task Board collaboration, and MCP configuration, still require users to understand Agent architecture itself.

Summary

The One 0.1.0 delivers a clear starting point:

You can create Agents, combine tools and Skills, build Multi-Agent Graphs, run them inside local projects, and observe in real time how Agents communicate, reason, call tools, and collaborate to complete work.

This is the first step for The One: moving Multi-Agents from code experiments into a visual, runnable, debuggable, and evolvable desktop workbench.