ArchPilot — Full Platform Intelligence

Not just a meeting listener. A complete engineering intelligence platform that ingests meetings, diagrams, code, and ADRs — and provides expert-level review, best practices, risk analysis, and visual editing across all of them.

5 Intelligence Pillars • 4 Input Channels • 12 Output Types • 1 Knowledge Graph

The 5 Intelligence Pillars

ArchPilot is built on five interconnected intelligence engines. Every input (meeting, diagram, code, ADR) flows through all five, and they reinforce each other over time.

🎧

1. Meeting Intelligence

Real-time audio capture → STT → contextual AI analysis → live suggestions during technical discussions. Understands architectural decisions as they happen.

Real-time STT Live Suggestions Speaker Diarization Decision Detection
📊

2. Diagram Intelligence

Upload any architecture diagram (PNG/PDF/Draw.io/Excalidraw/Mermaid) → AI parses it into a component graph → detects anti-patterns → suggests improvements → lets you visually edit, replace, and compare.

Visual Parsing Component Detection Visual Editing Version Compare
💻

3. Code Intelligence

Connect GitHub/GitLab → parse AST via Tree-sitter → detect architectural patterns in actual code → compare decisions vs implementation → flag drift, anti-patterns, and tech debt.

AST Parsing Pattern Detection Decision-Code Drift PR Review
📝

4. ADR Intelligence

Auto-generate ADRs from meetings → review uploaded ADRs for completeness → cross-reference with past decisions → detect conflicts and superseded decisions → maintain a living ADR repository.

Auto-Generation Quality Review Conflict Detection Living Repository
🏆

5. Best Practices Engine

A living knowledge base of engineering best practices across all domains — updated by industry standards, team learnings, and community patterns. Surfaces contextual recommendations everywhere.

Industry Standards Team Learnings Contextual Advice Pros/Cons/Risks

🔌 How Everything Connects — 4 Input Channels → 5 Engines → 12 Outputs

🎧 Meeting Audio

Live or recorded

📊 Diagrams

PNG/PDF/Draw.io/Mermaid

💻 Codebase

GitHub/GitLab repos

📝 ADRs & Docs

MD/PDF/Confluence

→
→
→
→
ArchPilot Intelligence Core
Meeting Engine Diagram Engine Code Engine ADR Engine Best Practices
Knowledge Graph Anti-Pattern DB Semantic Cache
→
→
→
→

Live Suggestion Cards

Improved Diagrams

Code Review Reports

Generated / Reviewed ADRs

Best Practice Guides

Risk & Cost Analysis

Failure Simulations

Tech Debt Maps

Compliance Reports

Multi-Version Comparisons

Decision History Search

Team Knowledge Insights

Pillar 2 — Diagram Intelligence Pipeline

The complete flow from uploading a diagram to getting an AI-improved, editable, comparable architecture.

FULL PIPELINE Diagram Upload → Parse → Analyze → Suggest → Edit → Compare

Step 1

Upload Diagram

PNG/PDF/SVG/Draw.io
Excalidraw/Mermaid

→

Step 2

Visual Parser

GPT-5.2 Vision
extracts components

→

Step 3

Graph Builder

Components → Nodes
Connections → Edges

→

Step 4

Anti-Pattern Scanner

Rules + AI check
40+ known patterns

→

Step 5

Suggestion Generator

Alternatives with
pros/cons/risk/cost

→

Step 6

Visual Editor

React Flow canvas
drag/replace/rewire

→

Step 7

Version Compare

Side-by-side diff
scoring matrix

▶ Step 1 — Multi-Format Diagram Ingestion Parser

Users shouldn't need to redraw their architecture in your tool. ArchPilot should ingest whatever they already have.

FormatParsing StrategyOutput
PNG/JPG/ScreenshotGPT-5.2 Vision → component extraction + OCR for labelsStructured JSON graph
PDF (exported diagrams)PDF-to-image → same as PNG pipelineStructured JSON graph
Draw.io / Diagrams.net (.xml)Direct XML parsing → extract mxCell elements, connections, stylesNative graph with metadata
Excalidraw (.excalidraw)JSON parsing → extract elements, arrows, text labelsPositional graph
Mermaid (.md)Mermaid parser → AST → graph extractionSemantic graph
SVGSVG DOM parsing + AI label extractionStructured JSON graph
Terraform/CDK/PulumiIaC parser → resource extraction → relationship mappingInfrastructure graph
▶ Step 4 — Anti-Pattern Detection on Diagrams 40+ Patterns

The anti-pattern scanner runs both rule-based checks (graph analysis) and AI-based checks (contextual understanding). Each finding includes severity, explanation, and fix.

⚠ Structural Anti-Patterns

  • Single point of failure (node with no redundancy)
  • Synchronous chain > 4 services deep
  • Shared database between microservices
  • Missing load balancer before service tier
  • No circuit breaker on external API calls
  • Circular dependency between services
  • God service (> 8 incoming connections)

⚠ Data Flow Anti-Patterns

  • No cache layer between service and DB
  • Dual writes without event sourcing
  • Missing dead letter queue on message broker
  • No CDN before static assets
  • Sync reads from write-primary DB
  • Missing read replica for query-heavy services

⚠ Security Anti-Patterns

  • Public-facing service directly accessing DB
  • No API gateway / auth layer
  • Secrets not routed through vault
  • Cross-zone traffic without encryption
  • Missing WAF before public endpoints
  • No network segmentation
▶ Step 5-6 — Component Replacement & Visual Editing Interactive

This is where ArchPilot becomes magical. User clicks a component in the diagram → AI suggests replacements → each replacement shows pros/cons/risks/cost → user clicks "Replace" → diagram updates in real time.

Component Replacement Flow

User clicks "RDS"
in diagram

→

AI generates
3-5 alternatives

Aurora, DynamoDB,
PlanetScale, CockroachDB

→

Each shows:

Pros, Cons, Risk,
Cost, Effort, Score

→

User picks
"Aurora Serverless"

→

Diagram auto-updates

Connections rewired,
config adjusted

→

Cascade Analysis

Impact on connected
services recalculated

Pro: Why This Matters

  • Engineers see alternatives they didn't know existed
  • Every swap shows real cost/performance numbers
  • Cascade analysis prevents "fixed one thing, broke three"
  • Version history of every diagram edit

Con: Challenges

  • Vision parsing accuracy varies with diagram quality
  • Connection rewiring requires deep understanding
  • Cost estimates need real pricing data (Infracost API)
  • Complex diagrams (50+ nodes) may overwhelm AI

Risk: Watch Out For

  • AI suggests theoretically better but operationally harder option
  • Vendor-specific suggestions create lock-in
  • Cost estimates may be stale — need real-time pricing refresh
  • Users trust AI too much — need confidence scores + reasoning
▶ Step 7 — Multi-Version Comparison Engine Differentiator

After editing, users can compare versions side-by-side. Each version is scored across 8 dimensions.

DimensionVersion A (Original)Version B (AI Optimized)Version C (Cost Optimized)
Reliability Score62/10089/10074/100
Scalability Score45/10092/10071/100
Security Score58/10085/10060/100
Monthly Cost$2,400$4,100$1,800
Operational ComplexityLowMediumLow
Migration Effort—3-4 weeks1-2 weeks
Anti-Patterns Found713
Compliance ReadyNoSOC2 + HIPAASOC2 only

Pillar 3 — Code Review Intelligence

Connect your actual codebase. ArchPilot reads the code, understands the architecture from the implementation, compares it to decisions, and reviews PRs for architectural impact.

FULL PIPELINE Codebase → Parse → Understand → Review → Recommend

GitHub / GitLab

Connect repo via
OAuth + webhooks

→

Tree-sitter AST

Parse all source files
into syntax trees

→

Architecture Extractor

Detect: services, APIs,
DB calls, message flows

→

Pattern Analyzer

Match against 60+
architecture patterns

→

Drift Detector

Compare code reality
vs diagram/decisions

→

Review Engine

Generate findings
with fix suggestions

▶ Code Architecture Extraction — What It Detects AST + AI

Service Boundaries

Detects: module boundaries, package structure, dependency graphs between services, import patterns. Answers: "Is this actually a monolith disguised as microservices?"

API Contracts

Extracts: REST endpoints, GraphQL schemas, gRPC proto definitions, WebSocket handlers. Validates: versioning strategy, error handling, auth middleware presence.

Data Access Patterns

Detects: ORM usage, raw SQL, N+1 queries, missing indexes (from query patterns), connection pooling, transaction boundaries, read/write splitting.

Error Handling & Resilience

Checks: try/catch coverage, retry logic presence, circuit breaker usage, timeout configurations, graceful degradation patterns, dead letter handling.

Security Patterns

Scans: auth middleware on routes, input validation, SQL injection vectors, XSS risks, hardcoded secrets, insecure crypto usage, CORS configuration.

Design Pattern Usage

Identifies: repository pattern, factory, strategy, observer, CQRS, event sourcing, saga, DDD aggregates. Flags: pattern misuse, incomplete implementations.

▶ Decision-to-Code Drift Detection Key Feature

This is where all the pillars connect. ArchPilot compares what was decided (from meetings + ADRs + diagrams) against what was actually implemented (from code). The gap between "we decided" and "we built" is where the most dangerous tech debt lives.

Decision (from meeting/ADR)Code RealityDrift TypeSeverity
"Use event-driven architecture for order processing"Found: synchronous HTTP calls between order → payment → inventoryArchitecture DriftCritical
"All services must have circuit breakers on external calls"3 of 8 services missing circuit breaker on payment APIImplementation GapHigh
"Use PostgreSQL for user data"User service using PostgreSQL ✓AlignedNone
"API versioning via URL path (/v1/, /v2/)"Mix of URL path + header-based versioning foundInconsistencyMedium
"Separate read/write DB for catalog service"Single DB connection string, no read replica configuredNot ImplementedHigh
▶ PR-Level Architecture Review GitHub Integration

Every PR gets an automatic architectural impact assessment. Not just "is the code clean" — but "does this PR change the architecture, and is that change aligned with our decisions?"

Low Impact PR

"Bug fix in user validation — no architectural impact. Approved. ✓"

Medium Impact PR

"New direct DB dependency added in checkout service. This introduces coupling. Consider using the existing event bus instead. ADR-042 recommends event-driven patterns for this flow."

High Impact PR

"This PR adds a shared database between user-service and billing-service. This violates ADR-015 (service isolation). This creates a distributed monolith risk. Recommend: add API call or event. Blocking review required."

Pros

  • Catches architectural violations before merge
  • Links PR review to actual team decisions (ADRs)
  • Reduces "architecture erosion" over time
  • New team members learn team conventions via reviews

Cons

  • May slow down PR velocity if too aggressive
  • False positives frustrate developers
  • Needs tuning period to learn team's actual patterns
  • Requires GitHub App with code read permissions

Risks

  • Developers bypass by splitting PRs to avoid detection
  • Over-reliance on AI review reduces human thinking
  • Stale ADRs cause false drift alerts
  • Security: code sent to LLM APIs needs PII filtering

Pillar 4 — ADR Intelligence Engine

Architecture Decision Records aren't just generated — they're reviewed, cross-referenced, conflict-checked, and kept alive as a living system.

4 MODES ADR Lifecycle

Auto-Generate

From meetings:
AI writes ADR from
discussion context

→

Review & Score

Upload existing ADR:
AI scores completeness,
flags gaps, suggests fixes

→

Cross-Reference

Link related ADRs,
detect conflicts,
find superseded ones

→

Living Repository

Semantic search,
status tracking,
periodic health checks

▶ ADR Quality Scoring — What Gets Reviewed 12 Criteria

When a user uploads an ADR (or one is auto-generated), ArchPilot scores it across 12 dimensions. Most ADRs in the wild score 40-60%. ArchPilot helps get them to 85%+.

CriterionWhat It ChecksCommon Failure
Context CompletenessDoes it explain WHY this decision was needed?Jumps straight to solution without explaining the problem
Options ConsideredWere at least 3 alternatives evaluated?Only lists the chosen option, no alternatives
Trade-off AnalysisPros/cons for each option with reasoning?Lists pros of chosen option only, no cons
Decision ReasoningClear explanation of WHY this option won?"We chose X" without explaining why not Y
Consequences DocumentedWhat changes as a result? What's the impact?Missing entirely in 70% of ADRs
Risk AssessmentWhat could go wrong? What's the mitigation?Overly optimistic — no risks mentioned
Reversibility StatementHow hard is it to reverse this decision?Missing — creates false sense of flexibility
Scale AssumptionsAt what scale does this decision apply?Decision made for 100 users, applied at 1M users
Cost ImplicationsEstimated cost impact?No cost analysis whatsoever
Compliance ImpactAny regulatory/compliance implications?HIPAA/SOC2 impact not considered
Expiry / Review DateWhen should this decision be revisited?Missing — decisions become stale assumptions
Cross-Reference LinksRelated/superseded/dependent ADRs linked?ADRs exist in isolation, no connections
▶ ADR Conflict Detection — Finding Contradictions Critical

As ADR count grows (50, 100, 200+), contradictions emerge. Team A decided "use REST everywhere." Team B decided "use gRPC for internal services." Neither team knows about the other's ADR. ArchPilot catches this.

Direct Conflict

ADR-015: "Use PostgreSQL for all new services"
ADR-047: "Use DynamoDB for user sessions"
→ Conflict: data store strategy is inconsistent

Implicit Conflict

ADR-023: "All services must be stateless"
ADR-056: "Use in-memory caching in order service"
→ Tension: in-memory cache introduces state

Superseded

ADR-008: "Use JWT for auth" (2023)
ADR-061: "Migrate to session-based auth" (2025)
→ ADR-008 should be marked Superseded

Pillar 5 — Best Practices Engine

A living, contextual knowledge base that surfaces engineering best practices, design principles, pros/cons, and risks — not as a static wiki, but as intelligent, contextual recommendations woven into every feature.

▶ How Best Practices Surface — Not a Wiki, a Living Advisor Core Concept

Best practices don't sit in a searchable database. They surface contextually, exactly when relevant, through every pillar:

ContextHow It SurfacesExample
During meetingLive suggestion card when pattern is discussed"You're discussing event sourcing — here are the 5 prerequisites most teams miss: ..."
On diagram reviewAnnotation on component when anti-pattern detected"This synchronous chain violates the 'Bulkhead Pattern' — here's why and how to fix it"
On code reviewInline comment on PR with practice reference"This retry logic lacks jitter — see exponential backoff best practice with jitter formula"
On ADR reviewSuggested additions when ADR is incomplete"Your ADR mentions cost but no 12-month projection — best practice: include growth curve"
On searchEnriched results with current best practice context"You chose RDS in Q1 — since then, Aurora Serverless v2 pricing changed. Worth revisiting?"
▶ Best Practice Categories — The Full Taxonomy 11 Domains

☁️ Cloud Architecture

Multi-region strategies, service selection decision trees, cost optimization patterns, well-architected framework alignment.

🛠️ Application Design

Monolith decomposition criteria, service mesh patterns, strangler fig migration, CQRS readiness checklist.

🗃️ Data Architecture

Database selection matrix, caching strategies, consistency models, partitioning approaches, migration patterns.

🔒 Security Architecture

Zero trust implementation, OAuth flows, secret management, network segmentation, threat modeling.

🚀 API Design

REST maturity model, GraphQL complexity budgeting, gRPC vs REST decision tree, versioning strategies.

⚡ Event & Messaging

Broker selection, ordering guarantees, exactly-once patterns, dead letter strategies, saga patterns.

🔧 DevOps & CI/CD

Deployment strategies (blue/green, canary, rolling), IaC patterns, GitOps, environment promotion.

📈 Scalability

Horizontal vs vertical scaling, autoscaling patterns, database scaling strategies, load balancing algorithms.

🎯 Reliability

Chaos engineering, disaster recovery, RTO/RPO planning, circuit breakers, graceful degradation tiers.

💰 Cost Engineering

FinOps practices, reserved vs spot vs on-demand, right-sizing, cost allocation, waste detection.

👥 Team Topology

Conway's Law alignment, team cognitive load, platform team patterns, stream-aligned teams.

▶ Every Recommendation Includes — The ArchPilot Standard Standard

Every single recommendation ArchPilot makes — whether from a meeting, diagram review, code review, or ADR — follows this structure. No vague advice. Everything is actionable and scored.

Example: "Consider Aurora Serverless v2 Instead of RDS PostgreSQL"

PROS

  • Auto-scales to zero — saves 60% on dev/staging
  • Handles 10x traffic spikes without pre-provisioning
  • PostgreSQL compatible — minimal code changes

CONS

  • Cold start latency (2-5s) after scale-to-zero
  • More expensive at steady high load vs provisioned
  • AWS lock-in — harder to migrate later

RISKS

  • Cold start may cause timeout on first request after idle
  • Aurora Serverless v2 pricing can spike unexpectedly at scale
  • Some PostgreSQL extensions not supported

METRICS

  • 🎯 Confidence: 82%
  • ⚠️ Risk if Ignored: Medium
  • 💰 Cost Impact: -$340/mo
  • 🔧 Effort to Switch: 2-3 days
  • ↩️ Reversibility: Easy
  • 📊 Best Practice Alignment: AWS Well-Architected: Cost Optimization Pillar

All Input Channels — What Users Can Feed Into ArchPilot

The more context ArchPilot has, the smarter it gets. Every input enriches the knowledge graph and improves all outputs.

🎧 Live Meeting Audio

System audio from any app — Zoom, Teams, Meet, Slack Huddles, Discord. Real-time STT with speaker diarization. Triggers live suggestions within 3-5 seconds.

All PlatformsReal-timeSpeaker ID

🎥 Recorded Meetings

Upload .mp4/.webm/.m4a recordings. Processed offline with higher accuracy. Same analysis pipeline, but post-hoc — generates ADRs, summaries, and suggestions.

MP4/WebM/M4ABatch Processing

📄 Meeting Transcripts

Paste or upload text transcripts (from Otter.ai, Fireflies, manual notes). Skips STT, goes straight to context assembly and AI analysis.

Text/MD/PDFPhase 1 MVP

📊 Architecture Diagrams

PNG, PDF, SVG, Draw.io (.xml), Excalidraw, Mermaid. Vision AI parses into component graph. Full edit, replace, compare pipeline.

7 FormatsVisual AI

☁️ Infrastructure as Code

Terraform, CDK, Pulumi, CloudFormation. Parses IaC into architecture graph automatically. Compares intended infra vs actual deployment.

TerraformCDKPulumi

💻 GitHub / GitLab Repos

Connect via OAuth. Tree-sitter AST parsing extracts architecture from code. Webhook-triggered PR review for architectural impact.

OAuthWebhooksPR Review

📦 Code Snippets

Paste code directly into chat. ArchPilot analyzes: patterns used, anti-patterns, improvement opportunities, design principle violations.

Any LanguageQuick Analysis

📝 Existing ADRs

Upload MD/PDF ADRs. ArchPilot scores quality, identifies gaps, suggests improvements, cross-references with knowledge base.

MD/PDFQuality Score

📖 Technical RFCs & Docs

Upload design docs, RFCs, technical specs. AI extracts decisions, constraints, and assumptions. Links to relevant ADRs and past discussions.

RFC/SpecDecision Extraction

💬 Natural Language Chat

"What's the best way to handle auth for a mobile app?" — ArchPilot answers with best practices, pros/cons, and links to team's past decisions.

ConversationalContext-Aware

The Knowledge Graph — ArchPilot's Brain

Every input feeds a central knowledge graph. Over time, this becomes the most valuable asset — the institutional memory that makes ArchPilot irreplaceable.

What Lives in the Knowledge Graph

Decisions

What was decided, why, by whom, when, alternatives rejected

Components

Every service, DB, queue, cache — current and historical

Patterns

Architecture patterns in use, where, and how well implemented

People

Who knows what, who decided what, who owns what

Risks

Known risks, tech debt, time bombs, compliance gaps

Anti-Patterns

Detected anti-patterns, where in code/diagram, severity

Costs

Per-service cost, cost trends, optimization opportunities

Timeline

When things changed, evolution of architecture over months

▶ Knowledge Graph Queries — What Users Can Ask Natural Language
Query TypeExampleWhat KG Returns
Decision History"Why did we choose Kafka over RabbitMQ?"Original discussion transcript, ADR, participants, date, alternatives considered with reasoning
Expertise Finder"Who knows most about our payment architecture?"Team members ranked by discussion frequency, decisions made, code ownership in payment service
Impact Analysis"What depends on the user-service database?"All services with DB connections, API consumers, downstream impacts, blast radius visualization
Tech Debt Query"What's our biggest architectural risk right now?"Ranked list of risks from: drift detection, anti-pattern scans, flagged discussions, stale decisions
Pattern Search"Where do we use event sourcing?"Services, code locations, diagram references, related decisions, implementation quality score
Cost Query"What's our most expensive service to run?"Service cost breakdown, trend over time, optimization suggestions with estimated savings
Compliance Query"Are we HIPAA compliant?"Compliance checklist with pass/fail per requirement, linked to specific components and gaps
Evolution Query"How has our auth architecture changed over time?"Timeline view: decisions, diagram versions, code changes, ADRs — chronologically mapped
▶ The Compound Effect — Why This Gets Better Over Time Moat
TimeframeKnowledge Graph StateValue Delivered
Month 15-10 meetings, 2-3 diagrams, 1 connected repoBasic suggestions, initial ADRs, first anti-pattern scans
Month 340+ meetings, 10+ diagrams, 5 repos, 20 ADRsCross-referencing kicks in. "Last time you discussed caching, you decided X. Has that changed?"
Month 6100+ meetings, full diagram history, drift detection activeProactive alerts: "Your order service has drifted from ADR-15. 3 teams have discussed this concern."
Month 12Complete architectural history of the organizationNew hire asks "how does our system work?" → ArchPilot gives a full tour with reasoning for every decision. Irreplaceable.

Why This Is the Moat

  • Knowledge accumulates — competitors start from zero
  • Switching cost grows exponentially with data
  • Network effect within org — more teams = smarter suggestions
  • Historical context can't be recreated

Risks to the Moat

  • Data portability demands (export all decisions + graph)
  • LLM quality improvements could narrow AI advantage
  • Open-source alternative with self-hosted knowledge base
  • Enterprise customers may demand data ownership

Defense Strategy

  • Offer data export (build trust, reduce switching fear)
  • Focus on integrations, not just AI quality
  • Community-contributed best practice packs
  • Enterprise: on-prem knowledge graph option