AI Agents for M&A Integration: Mapping and Auditing Acquired Systems

The deal closes on a Friday. By Monday, your integration team owns a codebase nobody on your side has ever opened, a security posture nobody has ever audited, and a set of engineers who are simultaneously relieved and terrified about what happens next. This is the moment ai agents for m&a integration actually earn their keep, not in the data room during diligence, but in the first two weeks after close, when someone has to answer three questions fast: what is this system, is it safe, and what is it going to cost us to run. Most integration teams answer those questions with a spreadsheet, a Zoom call with the acquired CTO who is already updating their LinkedIn, and a gut feeling. That is not a plan, it is a bet, and the technical debt you inherit overnight is the house's money.

Why ChatGPT and Cursor can't run point on integration

Paste the acquired company's repo structure into ChatGPT or Claude.ai and you get a plausible-sounding summary of what a Django monolith with 14 Go microservices probably does. Probably is the operative word. A generalist chatbot has no access to the actual codebase, the actual IAM configuration, the actual Terraform state. It reasons from the fragments you paste in, which means it inherits every blind spot you already had walking in. Ask it whether the acquired company's AWS accounts have any public-read S3 buckets and it will explain what a misconfigured bucket looks like in general. It cannot tell you whether one exists in the three AWS accounts you just inherited, because it has never seen them and never will unless a human manually feeds it every config file, one at a time, for weeks.

Cursor and Copilot solve an adjacent but different problem. They are excellent once an engineer is inside a specific file, writing a specific function, in a codebase they already understand at a structural level. Integration work starts before that point. Nobody has opened the file yet. Nobody knows which of the 110,000 lines in the acquired monolith are load-bearing and which are dead code from a 2019 feature that got ripped out of the frontend but never the backend. An autocomplete tool has no opinion on architecture, no mechanism for flagging that the acquired auth service hardcodes a JWT signing secret, and no way to price out what consolidating six AWS accounts into two will cost your combined cloud bill next quarter. It completes the line you are writing. It does not tell you which line to write first, in which system, on whose authority.

Atlas, Forge, and Warden take the intake

Tonone's answer to this is not one agent trying to do everything. It is three specialists doing the three jobs an integration actually requires in the first two weeks: Atlas maps the architecture so the team understands what it owns, Warden audits the security posture so the team knows what it is exposed to, and Forge prices the infrastructure so finance knows what the combined cloud bill will actually look like. Each does one job well instead of one agent doing three jobs badly, which matters because integration deadlines are measured in days, not sprints.

Tonone's Atlas maps an acquired system's architecture, services, dependencies, and data flows before any integration work begins, producing the intake document a takeover team would otherwise spend two weeks assembling by hand.

Atlas reads the system before anyone touches it

The atlas-recon skill is the first thing to run against an acquired repository. It walks the directory structure, identifies the stack and framework versions in use, locates the config files that actually matter, maps the external integrations (payment processors, data pipelines, third-party APIs), and flags anything that changes the shape of the integration, like a hardcoded credential, a service with no owner listed in any onboarding doc, or a dependency that has not been updated since a framework's previous major version. It is the fast pass that tells the team what they are looking at before they commit real hours to it.

Once the recon is done, atlas-map produces the actual architecture diagram: a C4-level map of services and how they connect, rendered as Mermaid so it can live in a wiki page or a board deck without anyone redrawing it by hand. For a two-codebase acquisition, this is the single artifact that turns "we don't know what we bought" into "here is the system, here is what talks to what, here is where the data actually lives." Teams that skip this step end up discovering the real architecture through outages six months post-close, which is a much more expensive way to learn the same information.

Warden audits what Atlas found

Architecture and security are two different questions, and Warden owns the second one. warden-recon inventories the acquired company's secrets management, IAM structure, dependency exposure, and auth model, the same kind of sweep a security team would run in week one of a new engagement, except it runs against the actual codebase and infrastructure config instead of a vendor security questionnaire that the acquired company filled out themselves. warden-audit goes deeper: full findings against IAM boundaries, encryption practices, and audit logging, prioritized by severity, so the integration lead has an actual punch list instead of a vague sense of dread.

Forge prices the combined infrastructure

Nobody signs off on an integration budget without a cost number, and forge-audit is how Tonone produces one. It reads the acquired company's cloud footprint (accounts, regions, reserved capacity, orphaned resources nobody has decommissioned) and produces a cost and risk assessment of what it will take to consolidate into the parent org's infrastructure. This is usually where an acquisition's real technical debt surfaces first, not in the code, but in the AWS bill: duplicate services running in two regions because nobody ever decommissioned the old one, six separate AWS accounts with no consolidated billing, reserved instances that expired and reverted to on-demand pricing eighteen months ago.

A worked example: Meridian Robotics acquires Cascade Systems

Meridian Robotics, a $40M ARR industrial robotics company, closes on Cascade Systems, an 18-engineer computer vision startup, on a Friday in June. The board wants an integration risk briefing in five business days. Cascade's stack: a Django monolith from 2017 running 110,000 lines of Python, 14 Go microservices on GKE, Terraform covering roughly 40% of the actual infrastructure (the rest was clicked together in the AWS console over four years), and a custom JWT auth service that nobody at Cascade has touched since the engineer who wrote it left in 2021.

Meridian's integration lead runs Atlas first. atlas-recon flags three things inside the first hour: the JWT signing secret is hardcoded in a config file that's committed to the repo (not in a secrets manager), two of Cascade's six AWS accounts have no owner listed anywhere, and the Django monolith imports a deprecated ORM extension that stopped receiving security patches in 2023. atlas-map follows with the architecture diagram, showing that customer LIDAR scan data flows through an S3 bucket that neither the Django monolith nor the Go services directly own, a third integration point nobody flagged during diligence because the diligence data room only covered the two systems Cascade's own engineers thought to document.

Warden runs next, against exactly what Atlas found. warden-recon confirms the hardcoded JWT secret is a live finding, not a false positive, and adds a second: that S3 bucket carrying LIDAR data has public-read enabled on two of its four prefixes. warden-audit scores the finding severity and produces the output below, the kind of punch list the integration lead brings into the five-day board briefing instead of a slide that says "security review in progress."

Warden Audit, Cascade Systems Intake, Day 3 of 5

CRITICAL
  JWT signing secret hardcoded in config/settings.py, committed to
  repo history since 2019. No rotation since. Affects auth for all
  14 Go microservices via shared token validation.
  Fix: rotate secret, move to secrets manager, invalidate all
  active sessions. Est. 1 day, requires a maintenance window.

CRITICAL
  S3 bucket cascade-vision-scans has public-read on 2 of 4 prefixes.
  Contains customer LIDAR scan data, no encryption at rest.
  Fix: lock down bucket policy, enable SSE-KMS, audit access logs
  for the exposure window. Est. 4 hours.

HIGH
  2 of 6 AWS accounts have no listed owner in IAM or any onboarding
  doc. Root credentials shared via a password manager entry last
  rotated in 2021.
  Fix: assign account owners, rotate root creds, enable MFA
  enforcement org-wide. Est. 2 days.

MEDIUM
  Django ORM extension unpatched since 2023, no CVE yet but end
  of upstream support confirmed.
  Fix: schedule migration off the extension, not urgent for close
  but should land within 90 days.

Recommendation: CRITICAL items block integration sign-off. Fix
before any Meridian service is granted network access to Cascade
infrastructure. HIGH item fixable in parallel, does not block.

In parallel, Forge runs forge-audit on Cascade's six AWS accounts and finds $340,000 a year in avoidable spend: duplicate GKE clusters running in two regions from an abandoned failover test, reserved instance coverage that lapsed in 2024 and quietly reverted forty instances to on-demand pricing, and an orphaned data warehouse cluster nobody has queried in eight months. That number goes straight into the integration budget the board sees on day five, next to the security punch list and the architecture map. Three agents, three domains, one coherent picture, delivered inside the five-day window instead of the six-to-eight weeks a fully manual audit would have taken with the two engineers Meridian could actually spare for it.

Tonone's Warden audits an acquired company's IAM structure, secrets management, and encryption practices, producing a severity-ranked punch list before any integration work touches the acquired infrastructure.

Once the critical findings are fixed, atlas-onboard turns the Atlas recon and map into onboarding documentation for the Meridian engineers who will actually maintain Cascade's systems going forward, and atlas-adr records the integration decisions themselves (why the JWT service gets rewritten instead of patched, why the two AWS accounts get merged into Meridian's org instead of staying separate) as architecture decision records, so the reasoning survives past the six-month mark when the acquisition team has moved on to the next thing and someone new is asking why the system looks the way it does. Six months out is exactly when this kind of decision trail usually evaporates: the two engineers who ran the original audit have rotated onto other projects, the Cascade CTO who could explain the historical context is long gone, and whoever inherits the maintenance burden is left reverse-engineering intent from commit messages. An ADR trail that captures the actual tradeoff, not just the outcome, is the difference between a five-minute read and a two-day archaeology project the next time someone asks why the auth service looks the way it does.

Install and try

Tonone is free and MIT-licensed. Install it once and Atlas, Forge, Warden, and the rest of the 100-agent roster are available in your Claude Code session for the integration work ahead. You pay only for the Claude Code token usage during the audit itself.