The Intent application for orchestrating a large number of AI coding agents has been open-sourced under the Apache 2.0 license, coinciding with the release of the stable v2.118.0 version. The project's core is the intentd daemon written in Rust with a JSON-RPC interface, and the work plan before agents start is fixed as a spec, which is created by the Coordinator agent. The tool addresses the bottleneck of parallel agent development: tasks live in isolated workspaces, do not mix files, and do not lose context, and the completion of each task is confirmed by an automatic check.

image

What happened

The Intent code has been published in the monorepo github.com/intent-hq/intent under the Apache 2.0 license, and the open-sourcing coincided with the release of the stable v2.118.0 version on August 31, 2026. The system's core is the intentd daemon written in Rust with a JSON-RPC interface, the user interface cloudlands-fe is built on the Electron and SvelteKit stack, and updates are distributed through a separate cloudlands-releases repository, where builds for macOS and AppImage for Linux are published. Within the application, each agent task is executed in an isolated workspace, and commits, reviews, and merges are built directly into the working interface through the Agents, Context, Changes, Files, Browser, and Shell panels.

Context

Tooling code around AI agents has until recently been concentrated in closed products, so teams launching dozens of agent tasks simultaneously had to assemble orchestration from custom scripts and faced conflicts in edits and loss of context between tasks. The Intent approach is based on the ideas of decomposition and automatic verification known from agent methodologies: a special Coordinator agent fixes the spec before work begins, agents themselves track changes and move on to the next task, and the readiness of each task is confirmed by a separate verifier based on the Definition of Done criterion, covering build, tests, and lint. It is also significant that the orchestrator is not tied to a specific model: it allows connecting your own CLI agents and mixing them by workspace, which turns it into a controlled research stand where the same orchestration loop can be tested on different base models.

Why this matters for the industry

For the industry, this is another step in the migration of tooling code around AI agents from closed startups to the open field: the architecture of parallel agent development can now be studied directly in the code, not from a press release, and forked and integrated into your own pipelines instead of custom scripts. The Apache 2.0 license and the availability of the intentd daemon via JSON-RPC make Intent a candidate for the role of an independent component for teams that are already running dozens of agent tasks simultaneously. If the community picks up the project, third-party reproductions, the first independent comparisons of orchestrators by the spec, verifier, and isolated workspaces scheme, spec template libraries, and external verifier agents with readiness policies for specific stacks are likely; if not, Intent will remain just another DIY tool. In the two-year horizon, agent orchestration will likely consolidate into a standard layer of development infrastructure, similar to CI, where value shifts from the orchestrators themselves to those who own the specs and methodology: how to build plans, what to consider a task readiness criterion, and how to calculate the cost of parallel runs.

Why this matters for users

If you are experimenting with coding agents like Claude Code or Codex-like CLI, Intent offers a way to run them in parallel by the dozens, without mixing files and without manually passing context between tasks: the work plan is set by the spec, automatic verification reports on the actually completed task, and commits with diffs remain in Git. A practical first step is to connect the CLI agents you are already using and run a batch of parallel tasks on a pilot project, comparing the result with manually launching agents one by one. For those who want to understand the mechanics in more depth, it is worth looking at the intentd core sources and seeing how workspaces, the verification stage, and agent transitions between tasks are organized there.

What is still unknown / limitations

The declared qualities of Intent are currently confirmed only by a demonstration: five Mapbox API endpoints, verified by a separate verifier agent, yielded 76 passed tests and clean build and lint, however, this is a smoke test, not an eval methodology. The tasks for the demo were chosen by the vendor itself and are limited to one class of tasks, there is no baseline for comparison, for example one agent sequentially versus a dozen in parallel, there is no data on the cost of parallel runs, there is no description of errors and iterations, and the phrase "76 tests passed" only fixes the fact that the check was performed. The delivery does not include reproducible evals, so the declared results will have to be checked independently on your own tasks, and the questions of latency and conflicts during merging remain open.

Sources

Author

Look at AI, editorial team