Questions we get about
AI Agent adoption

open-multi-agent is YuanASI's own open-source multi-agent orchestration engine. It's TypeScript-native: hand a goal to the Coordinator and it decomposes it into a task DAG at runtime, which a deterministic scheduler then executes in parallel. The core API is a single runTeam(team, goal) call.

It has just 3 runtime dependencies (@anthropic-ai/sdk, openai, zod); everything else is opt-in. It drops into any Node.js backend with no Python runtime. It ships with built-in support for Anthropic, OpenAI, Grok, DeepSeek, Doubao, Hunyuan, MiniMax, Qwen, Zhipu and more, and can run fully offline against local models via Ollama or vLLM. MIT-licensed; install with npm install @open-multi-agent/core.

In one line: Dify and Coze are best for no-code prototyping; LangGraph fits teams that want to hand-define a state graph up front; open-multi-agent fits TypeScript backends that want to hand the framework a goal and let it decompose the work.

Per the project's own docs: LangGraph has you design a declarative graph up front and compile it, whereas open-multi-agent decomposes the goal into a task DAG at runtime; compared with Python frameworks like CrewAI, it brings goal-driven orchestration to TypeScript backends with no separate Python service to stand up. Dify and Coze are low-code visual platforms — fast to start, but deep customization is limited. The right choice depends on your stack and how much control you need.

Custom development usually runs in four steps: (1) requirements and use-case diagnosis, (2) architecture and solution design, (3) development and integration, (4) deployment, acceptance, and handover.

Timeline depends on the complexity of the scenario, how much data and how many systems need integrating, and whether private deployment is required — we scope each engagement rather than quoting a fixed duration. We suggest starting with a free AI adoption diagnosis: describe your scenario and an AI Agent returns feasibility, architecture suggestions, and an adoption path on the spot, which is what we use to define scope and timeline.

Yes. open-multi-agent is a Node.js library embedded in your own backend, with just 3 runtime dependencies, no Python runtime, and no cloud sidecar; with local models via Ollama or vLLM it needs no API key and runs fully offline, so data never leaves your network.

YuanASI delivers full private-deployment engagements and supports on-premise model selection — placing the models, orchestration, and business systems inside your own environment according to your compliance requirements and hardware.

Split ROI into two sides: benefit = person-hours saved per run of a scenario × frequency × labor cost; cost = one-time development plus ongoing model-call and operations cost.

Start with one high-frequency, well-defined scenario as a pilot, fill this formula with real operating data, then decide whether to expand. That way the ROI call rests on measured data rather than guesswork.

It comes down to whether the task splits and needs division of labor: for a linear, single task, one agent is simpler; use multiple agents when the goal can be decomposed and needs several roles working in parallel.

open-multi-agent gives you a tiered API: runAgent() is one agent, one prompt; runTasks() lets you define the task graph yourself; runTeam() takes a goal and has the Coordinator decompose it into a DAG and run it in parallel; runConsensus() cross-verifies with a proposer→judge pass. Pick the tier that matches the task's complexity — you don't need multi-agent from day one.