Harness Acquires Augment Code Assets to Connect Coding Agents With Software Delivery

Writing a code change is becoming easier. Getting that change tested, reviewed, secured and running reliably for customers remains a much larger job. Harness is betting that the next advance in AI software development will come from connecting those two worlds.

On October 8, Harness announced that it has acquired selected Augment Code assets, including Cosmos, the Auggie CLI, the Code Context Engine and related technology. The team behind those products is joining Harness. Cosmos will become the Harness Cosmos Software Factory Agent, extending the company’s software delivery platform into the engineering work that happens before a change reaches a deployment pipeline.

The distinction matters: this is an acquisition of selected assets and their associated team, rather than a stated purchase of the entire Augment Code company. Its significance lies in the technology being brought together: agents that understand and modify a codebase, alongside systems that understand how that code is tested, released and operated.

What Harness is bringing into its platform

The announcement positions Cosmos as the starting point for an increasingly autonomous software development lifecycle, or SDLC. A requirement, assigned ticket or reported bug can initiate a coordinated workflow in which agents plan a change, write code and tests, and open a pull request. Engineers remain involved at judgment points, including approving a design and making the final merge decision.

This goes beyond generating an initial patch. Cosmos agents can keep working on the same pull request when reviewers leave comments or checks fail. Prebuilt Experts, including Project Builder, PR Author, Deep Reviewer and PR Fixer, give teams workflows they can adapt to their own repositories and standards.

Each agent operates in an isolated virtual machine. Model routing, integrations with GitHub, Jira and Slack, shared memory, versioning and budget controls provide the surrounding infrastructure for running that work across an engineering organization.

That combination is the software factory idea: a repeatable process that carries work toward a reviewable result. The important unit is a completed engineering workflow, with evidence and checkpoints, rather than the number of lines an agent produces.

How Cosmos works beyond the chat window

Augment’s Cosmos product page adds useful detail about that operating model. Pull requests, alerts, schedules and webhooks can activate specialized Experts. Teams define environments, integrations and human checkpoints around those triggers, allowing work to begin without someone manually issuing a new prompt for every event.

Cosmos also supports defining Experts and event-driven workflows as versioned YAML, applying changes through the Auggie CLI and managing configuration history in Git. This makes the agent workflow itself something a team can inspect and change through familiar engineering practices. The product page describes shared organizational knowledge and spending limits alongside those controls.

For a development team, this changes the coordination problem. An agent that responds to an assigned ticket needs a clearly scoped objective, access to the right tools and a place to report its result. An agent triggered by a failing check needs the failure evidence and permission to change the relevant files. Reusable workflows can encode those requirements, although their effectiveness still depends on how carefully the organization configures them.

The Code Context Engine is central to the deal

Agents working on enterprise software face a problem that a fluent coding response cannot solve by itself: finding the right context. A repository can contain multiple services, deprecated implementations, local conventions and dependencies that are difficult to infer from one file.

According to Augment’s explanation of its Code Context Engine, the system semantically indexes code and retrieves information relevant to the task. It draws on relationships across repositories and services, commit history, codebase patterns and supporting material such as documentation and tickets. Rather than placing an entire repository in a prompt, it ranks and curates relevant context.

The practical value is easier to understand through an example. A request to change a payment endpoint might also affect validation, a downstream service, a webhook handler and tests. Retrieving those connections can give a coding agent a better starting point than the endpoint file alone. That is an illustration of the problem the technology addresses, rather than a guarantee that every affected dependency will be found.

Harness is acquiring this context capability alongside the tools that put it to work. The broader opportunity is to connect knowledge of what the code does with evidence of what happens after it leaves the repository.

Connecting the repository to the running system

Harness already operates on the delivery side of the lifecycle. Its agents cover software delivery, security testing, runtime protection and cost management. The acquisition creates a path for engineering work prepared by Cosmos to move into those downstream workflows.

The company’s Software Delivery Knowledge Graph is designed to connect information from Git, CI/CD, cloud infrastructure, security and operational tools. Harness describes a semantic layer with structured relationships, canonical identities and access filtering. One practical example is resolving different names for the same service across a repository, Kubernetes and monitoring systems.

That identity problem is consequential. A vulnerability finding associated with a deployed service is more useful when it can be traced to the relevant artifact and code version. A test failure needs to be connected to the change actually under review. Collecting more logs does not automatically establish those relationships.

In its acquisition announcement, Harness describes connecting the Code Context Engine and Software Delivery Knowledge Graph as a planned next step. The intended feedback loop would return downstream findings to the engineering workflow so an agent can prepare a correction and send it through validation again. Readers should distinguish that integration direction from an assertion that every part of the combined workflow is already delivered.

Autonomy still needs a release decision

The proposed loop could reduce a familiar source of engineering overhead: reconstructing an issue and carrying its context between tools. If testing exposes a regression, the useful output is a correction tied to the failed check, followed by evidence that the correction works. Opening another pull request without that evidence would merely move the bottleneck.

Human oversight remains part of the architecture. Isolation limits the execution environment, but it does not establish that a patch is correct. Tests, code review, security checks and explicit approval boundaries serve different purposes. A green test suite can still miss a requirement, and a technically valid change can still be inappropriate for a particular release.

For customers evaluating the combined platform, the meaningful measures will be how often proposed changes survive review, how much rework they require, and what happens to reliability after release. Time saved preparing a patch should be weighed against time spent verifying it. Those are evaluation criteria, not performance results demonstrated by the acquisition announcement.

A bet on the full path from idea to production

Harness says Cosmos is available now and that customers can continue using their preferred coding tools. That leaves room for organizations to adopt the software factory workflows selectively, rather than treating the acquisition as a requirement to replace their entire development environment.

The strategic bet is clear. As code generation becomes a routine capability, the harder problem is maintaining context across the decisions that make software usable: implementation, review, testing, deployment and operation. Bringing Augment’s coding assets into Harness gives the company components on both sides of that divide.

The acquisition will ultimately be judged by whether those components form a dependable feedback loop. If a production finding can lead to a well-scoped fix, verified against the correct code and released under the team’s policies, the gain reaches beyond faster coding. It becomes a better way to turn engineering work into software customers can use.