AppMap
Runtime evidence for AI-assisted development

Code changes outrun our understandingSee how every change behaves before it merges

AppMap records and compares application behavior. Developers inspect the diagrams. Coding agents query the same traces.

Install for VS CodeInstall for JetBrains
AppMap dependency map of a running application, showing packages, classes, and the calls between them.

Map. Analyze. Share. Repeat.

The code is shipping. Confidence is not.

AI writes more of your codebase every month. Almost no one knows what it actually does.

  • 96%

    of developers do not fully trust AI-generated code

    Sonar, 2026
  • 70%

    of software leaders say quality has already degraded as AI sped up delivery

    SmartBear, 2026
  • 60%

    hit quality issues last year because code outran testing

    SmartBear, 2026

Catch unexpected behavior while the change is still in the editor.

AppMap gives developers and coding agents runtime evidence as they work, so they can investigate calls, queries, exceptions, and side effects before the change merges.

What developers say about AppMap

Rated five stars by developers across the Visual Studio Code and JetBrains marketplaces, from a community of more than 100,000 developers.

★★★★★

"Helped me better understand and analyze the hierarchy and structure of my applications. Looks awesome, performs great, and provides truly invaluable feedback."

Max, Java developer, VS Code Marketplace
★★★★★

"An awesome plugin for sequence diagrams."

Shaun Wang, Java developer, JetBrains Marketplace
★★★★★

"AppMap improves productivity on both fronts, coding and documentation. It has become an inseparable part of our development process."

Venkat Bagam, Cognitive Zen

See what every change does.

AppMap runs in development and CI, before code merges. Each change produces fresh traces. AppMap turns them into maps developers can inspect to see what ran, what the change touched, and where behavior moved.

AppMap call tree showing the request path through the application.
The call treeThe request path the agent queried.
AppMap view of the SQL queries executed during a request, shown as parameterized statements.
The queriesThe exact SQL it ran, query by query.
AppMap code map of functions, APIs, and objects captured in the trace.
The code objectsFunctions, classes, and queries captured in the trace.

Three representative views. Explore the broader visual set in your editor before the change merges.

Stop reviewing code. Start reviewing behavior.

AppMap records how the application behaves and compares that behavior across revisions. As the code changes, AppMap records fresh traces and shows what held and what changed. Developers inspect the diagrams. Coding agents query the same traces. The review can go straight to the pull request.

AppMap workflow: the coding agent runs the tests, AppMap records fresh traces, and AppMap compares the behavior of the head revision with the base revision before merge
  1. 1

    Coding agent changes the code

    The coding agent makes the change.

  2. 2

    AppMap records fresh traces

    The coding agent runs the tests. AppMap records the behavior and shows the traces as maps.

  3. 3

    AppMap compares the behavior

    AppMap compares behavior in the changed revision with behavior in the base revision and reports what changed.

  4. 4

    The review is written into the pull request

    AppMap writes the review into the PR so reviewers see what changed in behavior, not just in code.

2-3
Sequence diagram of a client request flowing through JWTAuthFilter, ActorService, ActorDao, and Postgres, with the changed order-by query highlighted in amber
The trace as a sequence diagram. The amber call changed between the base revision and the head revision.View the full trace

Every pull request explains its behavior and impact.

A pull request should show more than what code changed. AppMap adds visual runtime evidence and a behavioral write-up: what ran, what changed, and whether the change behaved as intended.

Developers can inspect the diagrams. Coding agents can query the same traces. The pull request carries the resulting behavioral review. The evidence comes from the running application, not from the AI evaluating its own work. AppMap works with Claude Code, Cursor, GitHub Copilot, Windsurf, and any MCP-capable coding agent.

Runtime context changed the result.

Under a three-tool-call limit, agents using AppMap reached 100% root-cause accuracy. Source-only agents reached 28%.

The AppMap condition also used 3.4 times less model spend.

One internal study, Claude models. Method and limits in the benchmark.

Read the benchmarkReview the methodology

Developers trust AppMap

~140K
editor installs
VS CodeJetBrains
100K+
developer community
VS CodeJetBrains
2020
open source since
GitHub

Go deep before you merge.

Production and canary tracing are built to observe systems continuously with limited overhead. AppMap records deeply in development, capturing the code-level execution path, queries, HTTP calls, exceptions, and relationships behind the recorded runs. The result is information-dense context developers can inspect and coding agents can query before the change merges.

Learn how it works →

Canary / post-deploy

Broad, lightweight telemetry

  • API
  • Service A
  • Service B
  • Database
sampled spansservice boundariesproduction-safe detail

AppMap in development

Deep execution context

POST /charge  PaymentController#charge    ChargeService#authorize      RetryPolicy#wrap        LedgerService#write          SQL INSERT ...      IdempotencyStore#check        SQL SELECT ...    HTTP -> risk-service  200 OK · 142ms
function callsSQLHTTPexceptionscode objectstimingrelationships

Observe broadly in production. Understand deeply in development. More information per run gives developers and coding agents better context before merge.

Find problems that only show up when the code runs.

Deep runtime evidence exposes failures in behavior, not just structure. See performance problems, security and correctness issues, and unexpected changes while the code is still in development.

AppMap sequence diagram of one request, showing the full call path from HTTP to database.
Sequence diagram view. Fully interactive in your editor. Each trace captures the full request path from HTTP to database.
PERFORMANCE
  • Slow requests
  • N+1 queries
  • Repeated SQL
  • Expensive execution paths
SECURITY + CORRECTNESS
  • Auth gaps
  • Exceptions
  • Unsafe calls
  • Unexpected side effects
BEHAVIORAL CHANGE
  • API changes
  • Query changes
  • New dependencies
  • Unexpected drift in application behavior.

Use AppMap across the development pipeline

Run AppMap on developer machines and in CI. Keep traces in your environment. Connect your approved coding agents and model endpoints.

  • Local, self-hosted, and airgapped deployment
  • Model-independent agent access through MCP
  • Organization-wide Git and CI controls
  • Sanitized, repository-owned Gold Traces
Explore EnterpriseRead the Security FAQ

Know what your software does before you merge it.

Maps for developers. Runtime context for coding agents. Behavioral diffs before merge. Start free in VS Code or JetBrains.

Install for VS CodeInstall for JetBrains
NVIDIA Inception
GitHubfor Startups
MongoDB Partner
TechCrunch Finalist