Harness acquires Augment Code assets to connect coding agents with software delivery

Writing a code change is getting easier. Getting change tested, reviewed, secured and executed reliably for customers remains a much more challenging job. Harness is betting that the next breakthrough in AI software development will come from connecting these two worlds.

On October 8, Harness announced that it had acquired select Augment Code assets, including Cosmos, Auggie CLI, Code Context Engine and related technology. The team behind these products joins Harness. The cosmos will become the Agent Harness Cosmos Software Factoryextending the company’s software delivery platform to the engineering work that occurs before a change reaches a delivery pipeline.

The distinction is important: This is an acquisition of select assets and their associated team, rather than a declared purchase of the entire Augment Code company. Its significance lies in the technology that is brought together: agents that understand and modify a code base, along with systems that understand how that code is tested, released, and managed.

What Harness is bringing to 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 start a coordinated workflow where agents plan a change, write code and tests, and open a pull request. Engineers remain involved in moments of judgment, including approving a design and making the final casting decision.

This goes beyond generating an initial patch. Cosmos agents can continue working on the same pull request when reviewers leave comments or checks fail. Pre-built experts, including Project Builder, PR Author, Deep Reviewer, and PR Fixer, provide teams with workflows they can adapt to their own repositories and standards.

Each agent operates in an isolated virtual machine. Template routing, integrations with GitHub, Jira, and Slack, shared memory, versioning, and budget control provide the surrounding infrastructure for getting work done in an engineering organization.

This combination is the idea of the software factory: a repeatable process that moves work towards a revisable result. The important unit is a complete technical workflow, with tests and checkpoints, rather than the number of lines produced by an agent.

How Cosmos works beyond the chat window

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

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

For a development team, this changes the coordination problem. An agent responding to an assigned ticket needs a clearly defined goal, access to the right tools, and a place to report the outcome. An agent triggered by a failed check needs proof of the failure and permission to modify the relevant files. Reusable workflows can codify these requirements, although their effectiveness still depends on how carefully your organization configures them.

The code context engine is critical to the agreement

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

According to Augment’s explanation of its Code Context Engine, the system semantically indexes code and retrieves task-relevant information. It is based on relationships between repositories and services, commit history, code base models, and supporting material such as documentation and tickets. Instead of placing an entire repository in one prompt, classify and curate relevant context.

The practical value is easier to understand through an example. A request to change a payment endpoint might also impact validation, a downstream service, a webhook handler, and testing. Retrieving such connections can give an encoding agent a better starting point than the endpoint file alone. This is an example of the problem the technology faces, rather than a guarantee that all affected dependencies will be found.

Harness is acquiring this context capability along with 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

The harness already operates on the delivery side of the life cycle. 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 to those downstream workstreams.

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

That identity issue is consequential. A vulnerability discovery associated with a distributed service is most useful when it can be traced back to the relevant element and code version. A test failure must be linked to the change actually under review. Collecting multiple logs does not automatically establish such relationships.

In the acquisition announcement, Harness describes the connection of the Code Context Engine and the Software Delivery Knowledge Graph as the next planned step. The intended feedback loop would feed downstream results back to the design workflow so that an agent can prepare a fix and send it back through validation. Readers should distinguish this direction of integration from the statement that every part of the combined workflow has already been provided.

Autonomy still requires a release decision

The proposed loop could reduce a familiar source of engineering overhead: reconstructing a problem and transferring its context between tools. If the test exposes a regression, the useful output is a fix tied to the failed check, followed by proof that the fix works. Opening another pull request without such proof would only move the bottleneck.

Human control remains part of the architecture. Isolation limits the execution environment, but does not establish that a patch is correct. Testing, code review, security checks, and explicit approval limits 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, significant measures will be how often proposed changes survive review, how much rework is required, and what happens to reliability after release. The time saved in preparing a patch should be weighed against the time spent testing it. These are evaluation criteria, not performance results demonstrated by the acquisition announcement.

A bet on the complete path from idea to production

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

The strategic bet is clear. As code generation becomes a routine feature, the most difficult problem is maintaining context in the decisions that make software usable: deployment, review, testing, deployment, and operation. Bringing Augment’s coding resources into Harness provides the company with components on both sides of that divide.

The acquisition will ultimately be judged on whether these components form a reliable feedback loop. If a production result can lead to a well-targeted fix, checked against the correct code, and released according to team policies, the payoff goes beyond faster coding. It becomes a better way to turn engineering work into software that customers can use.