AWorld Agent Harness
Turn domain expertise into multi-agent workflows that build, evaluate, and iteratively improve concrete outputs.
The workflows declare scoped permissions for some jobs and distinguish pull requests from publishing pushes, while the README allows human feedback during evolution. However, there is no evidence that agent tools enforce least privilege, request per-action confirmation, or provide a consistent preview of side effects. Model and API configuration through .env is mentioned, and tests show that prompts, answers, and sessions are persisted and replayed, but destinations, retention, redaction, access control, and key rotation are not documented. Dependencies are largely unpinned, Actions use movable version tags rather than commit digests, and no vulnerability scanning or update policy is shown. Autonomous code/media creation, background agents, and CI publishing have external effects without demonstrated recovery or rollback. Projects, skills, papers, and authors receive substantial attribution, but publisher identity and the formal accountability chain remain unclear.
The descriptions of the orchestrator, developer, evaluator, and evolution loop are internally coherent. Focused tests cover agent refresh, time injection, transcript deduplication, legacy recovery, and one-time replay, supporting ordinary static consistency. Deductions apply because only a small subset of components and edge paths is covered, with no evidence for end-to-end error propagation. Installation depends on external models, APIs, Conda, pip, and potentially browser or media services, but availability, compatible versions, and fallback behavior are unclear. Empty responses are handled by omission, yet user-facing failure messages, diagnostic codes, and recovery guidance are not shown.
The material explicitly addresses developers, researchers, and domain experts and supplies scenarios for app construction, deep search, video creation, evaluation, and several benchmark classes, fully supporting audience and scenario coverage. Global configuration, working-directory .env files, Python 3.11, a CLI, local session restoration, and varied subagents provide a sound environment-fit foundation. Capability claims are nevertheless broad, with no concrete matrix of supported and unsupported tasks, platforms, models, tools, or resource limits. Trigger rules, ambiguity handling, tool-selection constraints, and protections against mistaken invocation are also not demonstrated.
The README has clear sections for installation, configuration, automation, evolution, benchmarks, advanced features, and contribution, with links to recipes and focused documentation. Naming varies among AWorld, AWorld-CLI, Aworld, and AWorld Agent, leaving capitalization and product boundaries somewhat unstable. Installation is actionable but omits system prerequisites, locked versions, common failures, and uninstall steps. Examples are extensive and tests add usage evidence, although no actual FAQ is supplied. Limitations appear mostly as motivating problems rather than operational known limitations. The complete MIT text justifies full license credit. References to v2.0, dated achievements, and image-tag rules do not substitute for a release policy or changelog. Contribution invitations and an Inclusion AI copyright attribution exist, but maintainers, support expectations, security contacts, and ownership of updates are unspecified.
Recipes, a CLI flow, code samples, transcript restoration, and concrete output types indicate that results can feed development, research, and media workflows. Multi-agent orchestration, evaluation loops, CAST, and background parallelism offer plausible marginal value over a single model call. Deductions apply because usability and incremental benefit are supported mainly by demonstrations and assertions; the supplied files do not establish general output acceptance formats, implemented quality gates, or executed outcomes. Cost-benefit evidence is thin: a threefold speed claim lacks its measurement method, and model/API usage, media generation, storage, concurrency, and human-review costs are not characterized.
Many capability and benchmark claims point to recipes, repository examples, papers, models, or leaderboards. Tests provide code-level traceability for session and prompt handling, while workflows corroborate documentation and image-build paths, earning ordinary traceability and cross-file corroboration. The linked targets themselves are not included in the supplied evidence, so rankings, papers, and claims such as “3x,” “battle-tested,” or “nearly infinite context” cannot be independently checked here. Marketing passages also infer validation of the whole harness from benchmark results without consistently separating observations, experimental conditions, and inference.
- The agent can autonomously create or modify code, invoke search and media tools, and start background subagents. Add per-action authorization, scope restrictions, budgets, and side-effect previews before using it on real projects.
- Session tests show that user inputs and assistant outputs are written locally and replayed into model prompts. Avoid sensitive input until storage location, permissions, retention, and deletion behavior are confirmed.
- Installation and CI dependencies are mostly not pinned by immutable digest or a complete lockfile. Produce an inventory, scan for vulnerabilities, and pin trusted versions before deployment.
- Benchmark, speed, and context-capacity claims cannot be independently verified from the supplied files and should be treated as project assertions, not confirmed outcomes of this static assessment.
- No unified mechanism is shown for reverting generated changes, cancelling external operations, or recovering from session side effects. Run it under version control in an isolated workspace with recoverable backups.
What does this agent do, and when should you use it?
AWorld is a self-hosted agent framework and command-line platform whose primary user interface is `aworld-cli`. Its AWorld Agent interprets a goal, plans the work, and delegates tasks to specialized subagents including Developer, Evaluator, Video Diffusion, Audio Generator, and Image Generator. Developer can use CAST, the Code Abstract Syntax Tree system, to navigate and modify code, while Evaluator applies skills or human feedback in a build-evaluate-evolve loop. Documented outputs include application code, deep-search results, images, speech, and video, with reusable Skills and recipes supplying task-specific expertise. The execution boundary is the user's Python 3.11 environment and working directory, with model and API settings supplied through the configuration flow or a local `.env` file. It is a plausible fit for developers and researchers who want one harness for orchestration, evaluation, and multimodal production, but adopters should verify model-service support, exact configuration variables, and external generation costs before committing.
After the user starts aworld-cli in a working directory, the AWorld Agent interprets the objective, creates a plan, and assigns work to specialized subagents. Developer writes, debugs, and refactors code; CAST exposes code as an abstract-syntax-tree structure for hierarchical navigation, context compression, and dependency-aware edits. Evaluator can inspect an artifact with a Skill such as aworld-skills/app_evaluator/SKILL.md, report deficiencies to Developer, and repeat the cycle until a user-defined criterion is met or human feedback redirects it. Deep-search workflows can use the Agent Browser Skill, while media workflows combine Video Diffusion, Audio Generator, Image Generator, and subtitle, audio-insertion, or video-embedding skills to produce media files. SpawnSubagentTool supports non-blocking work through spawn_background, status inspection through check_task, completion waiting through wait_task, and result retrieval. The repository also includes examples for GAIA, IMO, OSWorld, VisualWebArena, and xbench, alongside material for agent training, data synthesis, and reinforcement learning.
- A product developer can request a small web application and have Evaluator repeatedly score its UI and send concrete corrections to Developer until a stated threshold is reached.
- An agent researcher can study or reproduce workflows for GAIA, OSWorld, VisualWebArena, xbench, or the documented IMO problem-solving experiment using the repository's examples.
- An engineering team working in a large codebase can use CAST for structural navigation, relevant-context compression, and dependency-aware localized changes.
- A content team can turn one prompt into educational, corporate-training, brand-marketing, social-media, or VTuber video output by combining video, image, speech, and post-processing skills.
- A developer building long-running research workflows can launch work with
SpawnSubagentTooland let the orchestrator continue other tasks before checking or collecting the result. - A domain expert can encode evaluation criteria in a shared Skill, then steer subsequent evolution cycles with automated scores or direct natural-language feedback.
What are this agent's strengths and limitations?
- Developer and Evaluator form an explicit improvement loop driven by objective scores or human feedback, rather than stopping after one generation attempt.
- CAST supplies hierarchical code navigation, relevant-context compression, and dependency-aware modification for the large-codebase problems described by the project.
SpawnSubagentToolexposes background tasks with status checks, bounded waiting, and result retrieval, allowing orchestrator work to overlap long-running subagent execution.- One harness covers code creation, deep search, image generation, speech, and video production, with reusable Skills and recipes carrying domain procedures.
- The project supplies concrete benchmark figures and related examples for GAIA, IMO, OSWorld, VisualWebArena, and xbench, which gives researchers specific evaluation starting points.
- Setup requires cloning the repository, creating a Conda environment, and installing both the root project and
aworld-cliin editable mode; no single stable-package installation command is documented. - The supplied configuration section does not list
.envvariable names, supported model providers, or credential schemas, so integration requires additional documentation review. - Model, video, speech, image, and browsing operations may depend on external services; pricing, rate limits, offline behavior, and data-handling boundaries are not documented here.
- The evolution loop is only as useful as its evaluation target or Skill; subjective work still relies on a human as the final evaluator.
- The reported benchmark results reflect project-published task sets and dated configurations and do not establish equivalent performance for every custom domain.
How do you install or deploy this agent?
The documented setup requires Git, Conda, Python 3.11, pip, and network access to obtain the repository and dependencies. Run:
git clone https://github.com/inclusionAI/AWorld && cd AWorld
conda create -n aworld_env python=3.11 -y && conda activate aworld_envpip install -e . && cd aworld-cli && pip install -e .
The repository is licensed under MIT. No alternative installation route or verified operating-system matrix is provided in the supplied material.
How do you use this agent?
Move to the directory where AWorld should work, then start configuration with:
aworld-cli --configAfter entering the model and API settings, launch the interface with:
aworld-cliAlternatively, create a .env file in that working directory with the required model and API settings. The supplied material does not name the core environment variables, supported providers, or credential formats, so a verified complete .env example cannot be reproduced here; credentials for the selected model or generation service must be available before the first task. For background execution in Python, initialize SpawnSubagentTool(subagent_manager=your_manager, conf=config), submit an ActionModel with action_name='spawn_background', then use check_task, wait_task, and a final check_task with include_result: True.
FAQ
Does AWorld require a particular model provider?
Can it run entirely offline?
What stops an automated evolution loop?
How are background-task failures or timeouts handled?
check_task and bounded waiting with wait_task and a timeout. Automatic retries, persistent recovery, and cross-process failover are not described in the supplied material.