With Cosmos, Augment Code wants to give AI coding teams shared memory and context

Teams are starting to run into a coordination problem with AI coding tools. Developers can now offload meaningful chunks of work to agents, but the results often stay isolated — tied to one person’s prompts, context, and setup.

Agent tooling company Augment Code is trying to address that with a new product called Cosmos, available now in public preview. The system is designed to sit across a company’s development environment, coordinating multiple agents, storing what they learn, and reusing that knowledge across a team.

The aim is to move beyond one-off interactions with assistants and toward agents that remain active over longer stretches — picking up tasks, executing them, and feeding results back into a shared system.

Carrying knowledge over

Tools such as Cursor and Claude Code have made it easier for developers to hand off tasks like refactoring code, generating tests, or preparing pull requests. Some systems now support longer-running jobs, where agents can continue working after a developer steps away — producing changes that can be reviewed later.

Augment itself has been moving in that direction. Its remote agents can run tasks asynchronously, handling bug fixes, refactoring, and documentation in parallel, even after a developer has stopped interacting with the system.

But these setups expose a gap. Most agents operate with limited memory beyond a single session. As Augment notes in its own documentation, agents are effectively stateless between sessions, which leads to repeated decisions, inconsistent conventions across teams, and lost context.

That creates a situation where multiple agents are doing useful work, but without a shared layer to retain what has already been learned.

Building systems around context

Cosmos is Augment’s attempt to address that layer. It connects to existing tools, runs agents locally or in the cloud, and maintains a shared record of context, outputs, and feedback across tasks.

That record is then reused. An agent working on a new task can draw on previous runs, rather than starting from scratch each time.

Augment illustrates this with a comparison between how work unfolds today and how it might look with Cosmos. In the “today” model, tasks are broken up by multiple interruptions — eight, in its example — where context is lost and has to be rebuilt. With Cosmos, that is reduced to a smaller number of checkpoints, where work continues with context carried forward.

Zoom

The distinction isn’t just about fewer steps, though that is of course part of it, but about how those steps are structured. Interruptions force agents to restart with limited memory of prior work, while checkpoints allow progress to continue with context intact.

The result is a more continuous thread of execution, where outputs from earlier stages inform what comes next.

Other companies are arriving at similar conclusions. Tessl, for example, treats the context and skills agents rely on as software in their own right — with a full lifecycle of build, evaluate, distribute, and optimise. Like Cosmos, Tessl’s agent enablement platform is built around the idea that agent knowledge needs to persist and improve over time, rather than being redefined from scratch with every task.

Toward agents that run continuously

One of the more noticeable changes across these systems is how agents are used. Agents are increasingly taking on longer-running tasks that continue beyond a single session, rather than being limited to short, interactive exchanges.

This introduces a different set of challenges. Once agents are running independently, the focus moves to how their behaviour is guided, how outputs are reviewed, and how prior work is reused across tasks.

Systems like Cosmos and Tessl reflect that development, each building around the idea that agents need a persistent layer of knowledge and context to function effectively at the team level.

What remains unresolved is how these approaches handle quality and correctness over time. Software development still relies on tests, reviews, and defined requirements. As agents take on more of the implementation work, those checks don't disappear — they still need to be applied, even as more of the work is delegated.