Augment Code

Augment Code is an AI-powered software development platform built for professional engineering teams working with large and complex codebases. The platform combines deep codebase understanding, AI coding agents, automated code review, software-development automation, and cloud execution environments to help teams move from development tasks to tested and reviewed software more efficiently.

Augment was founded in 2022 and emerged from stealth in 2024. The company was founded by Igor Ostrovsky and Guy Gur-Ari, with Scott Dietzen serving as CEO. Augment originally positioned its product as developer AI for teams, focusing on a major limitation of conventional coding assistants: understanding how large software systems, dependencies, APIs, and architectural patterns fit together.

Today, Augment has expanded into an agentic software-development platform centered around Cosmos. Cosmos is designed to run connected software-development workflows across the software lifecycle, from ticket intake and code creation through review, verification, deployment, and monitoring.

Context Engine

One of Augment Code’s defining technologies is its Context Engine, which provides AI agents with a deeper understanding of a software repository.

Instead of treating individual files or small snippets as isolated pieces of information, Augment builds contextual knowledge around the codebase, including relationships between components and dependencies. This allows developers to ask questions about unfamiliar systems, investigate bugs, understand architecture, and make changes that may span multiple parts of a repository.

The Context Engine is particularly aimed at large and long-lived codebases where a developer or conventional coding assistant may struggle to maintain sufficient context. Augment says its system is designed for codebases ranging from side projects to large enterprise monorepos.

AI Coding Agent

Augment’s Coding Agent allows developers to describe development tasks using natural language. The agent can inspect the repository, reason about the requested change, modify files, and work through software-development tasks.

Developers can use the agent to explain a codebase, investigate bugs, write functions, create tests, implement features, and handle follow-up development work. Augment’s documentation describes the agent as a central part of its current coding workflow.

The agent is available through Augment’s development environments and through Auggie CLI, which brings the agent, context engine, and tools into the terminal.

Cosmos

Cosmos is Augment’s current agent orchestration platform. Rather than providing only an AI assistant inside an editor, Cosmos is designed to coordinate multiple specialized agents and automate recurring software-development workflows.

Cosmos can connect triggers, agents, environments, tools, organizational knowledge, and human approval points. Teams can use built-in experts or create their own reusable experts for particular engineering workflows.

The platform supports workflows such as:

• Ticket-to-PR development
• Automated code review
• Test verification
• Security vulnerability remediation
• Incident investigation
• Dependency updates
• Engineering automation
• Scheduled development tasks
• Software migrations
• Developer onboarding

These workflows can be connected so that the output of one stage feeds the next.

Automated Code Review

Augment Code Review provides AI-powered review of GitHub pull requests. The system is designed to identify correctness, architectural, and cross-system problems rather than concentrating primarily on stylistic issues.

Augment introduced Code Review in December 2025 and positioned it specifically for large, long-lived codebases. It uses deep repository context and custom rules to reduce irrelevant review comments. The system can also learn from which review comments developers address.

Enterprise customers receive additional capabilities such as advanced analytics, user allowlists, MCP integrations, multiple GitHub organizations, GitHub Enterprise Server support, unlimited seats, and unlimited connected repositories.

Ticket-to-PR Automation

Cosmos can automate the process of turning development tickets into pull requests. An agent can investigate a ticket, make the required code changes, exercise the implementation, and send its work into the code-review workflow.

This allows engineering organizations to automate repetitive development work while retaining human approval at important quality gates.

Testing and Verification

Testing is integrated into Augment’s agentic software-development workflow. Cosmos includes a Tester expert that can exercise changes end to end and provide results, including screenshots.

This approach allows generated code to be tested as part of an automated workflow rather than simply producing source code and leaving verification entirely to the developer.

Security Remediation

Augment also supports automated security-remediation workflows. Its platform can connect vulnerability alerts to agents that investigate the affected code, determine the likely impact, and prepare remediation changes for engineering approval.

The current platform specifically presents a vulnerability-remediation workflow designed to move from a CVE alert toward a reviewed fix.

Incident Management

Cosmos includes an Incident Response Coordinator workflow for software incidents. Agents can investigate alerts, gather relevant context, identify likely causes, prepare timelines, and coordinate information for engineers.

This can reduce the amount of manual investigation required before an on-call engineer begins working on an incident.

Automations and Scheduling

Augment supports event-driven and scheduled software-development automations. Native triggers include GitHub, GitLab, Slack, Linear, Jira, schedules, and typed webhooks for other systems.

This allows teams to create recurring workflows such as dependency maintenance, engineering summaries, automated reviews, and other repetitive development operations.

Integrations and MCP

Augment supports native integrations and Model Context Protocol (MCP) servers. Native integrations allow agents to access external services and take actions on behalf of developers.

Current documentation lists integrations including GitHub, Linear, Jira, Confluence, Notion, Sentry, and Stripe. Additional tools can be connected through MCP, allowing Augment agents to work with external databases, APIs, browser automation, messaging systems, and other tools.

Augment also provides one-click MCP integrations for services such as CircleCI, MongoDB, and Redis.

Development Environments

Augment can be used through Visual Studio Code, JetBrains IDEs, and the Auggie CLI. JetBrains support includes environments such as IntelliJ IDEA, WebStorm, and PyCharm.

The VS Code and JetBrains integrations provide access to Augment’s context-aware agent and coding features, while Auggie CLI brings the same broader capabilities into terminal-based development workflows.

Cloud and Local Execution

Cosmos can run agents in managed cloud sandboxes, on customer machines, or across a combination of environments. The platform supports managed cloud infrastructure as well as customer cloud environments including AWS and GCP.

This flexibility is important for organizations that need to keep certain code or workloads inside controlled infrastructure.

Human-in-the-Loop Controls

Although Augment supports autonomous software-development agents, its platform is designed around human approval at important points.

Cosmos can pause workflows for review, resume them after approval or feedback, and require people to approve consequential actions. This makes the platform more suitable for enterprise engineering environments where AI-generated changes cannot simply be released without oversight.

Security and Privacy

Augment emphasizes enterprise security and privacy. The company states that it achieved SOC 2 Type II certification and does not train its AI models on customers’ proprietary code. Current pricing also identifies SOC 2 Type II and additional enterprise security controls such as SSO, OIDC, SCIM, CMEK, and ISO 42001 compliance.

Enterprise deployments can also use additional access controls, audit trails, data-residency options, SIEM integrations, and customer-managed encryption capabilities.

Pricing

Augment Code currently uses a usage-based pricing model rather than traditional per-developer pricing.

The current public pricing page lists:

Standard — $20/month

• $20 of included monthly usage
• Up to 50 seats
• Cosmos
• Coding Agent
• CLI access
• MCP and native tools
• Usage analytics
• Standard compute
• Up to 50 concurrent Cosmos sessions
• SOC 2 Type II

Business — $100/month

• $100 of included monthly usage
• Up to 50 seats
• Cosmos
• Coding Agent
• CLI access
• MCP and native tools
• Usage analytics
• Standard compute
• Daemon mode
• Up to 50 concurrent sessions
• Additional enterprise security and administration features

Enterprise — Custom pricing

• Custom user pricing
• Bespoke usage limits
• Volume-based annual discounts
• Unlimited users
• Custom compute
• Multi-region compute
• Unlimited concurrent sessions
• SSO, OIDC, and SCIM
• CMEK
• ISO 42001 compliance
• Data residency options
• Granular access controls
• Comprehensive audit trails
• Dedicated support

Standard and Business plans do not charge a per-seat fee and pool usage across the team. Additional usage can be purchased through pay-as-you-go top-ups.

Usage covers LLM inference, the Context Engine, and Cosmos compute. Augment states that LLM usage is billed according to the model provider’s public API pricing plus a 40% service fee, while compute is charged separately.

The pricing model has changed over time. Augment moved from user-message-based pricing to credit-based usage in October 2025, so older listings showing plans based on message counts or per-user pricing may no longer reflect the current model.

Review

Augment Code is a strong option for engineering organizations that need AI assistance across large, complicated software systems rather than simple code autocomplete.

Its biggest strength is its deep codebase context. The Context Engine is designed to understand relationships across repositories, which makes Augment particularly useful for debugging, architectural questions, refactoring, migrations, and changes that span multiple components.

The evolution from an AI coding assistant into Cosmos also makes Augment more ambitious than conventional IDE copilots. Teams can use agents for coding, code review, testing, security remediation, incident response, ticket processing, and recurring engineering automation.

Its enterprise controls are another advantage. Organizations can use human approval gates, access controls, audit trails, enterprise identity systems, MCP integrations, and customer-controlled infrastructure options.

The main drawback is complexity. Augment is increasingly designed as an engineering platform rather than a lightweight autocomplete tool, so teams may need more setup and governance to take full advantage of its capabilities. The usage-based pricing model also means monthly costs depend on actual model, context, and compute consumption.

Another limitation is that Augment is highly specialized. Its value is concentrated in software engineering, DevOps, code review, infrastructure, security remediation, and related technical workflows rather than general business productivity.

For organizations managing large repositories and wanting to automate substantial portions of the software-development lifecycle while keeping engineers involved at quality gates, Augment Code is a compelling choice.