Evidence-backed software understanding

Understand how your software actually works

Atlas connects business behavior to systems, source code, and change history so every explanation can be inspected, verified, and kept current.

Join the waitlist See how Atlas works

Built for private repositories. Permission-aware by design.

Step 1 · Business outcome

Refund issued to original payment method

Triggered upon settlement resolution and manager threshold validation.

Step 2 · Executable workflow sequence

Validate request
Check payment state
Create refund
Publish refund.completed

Step 3 · Participating systems and queues

Support PortalClient / UI
Orders APIGateway
Payments ServiceCore Domain
Event BusMessage Queue

"A refund requires a completed payment before dispatching payment provider calls."

42async function validateAndIssueRefund(orderId: string, amt: number) {43const tx = await paymentStore.findSettledPayment(orderId);44if (!tx || tx.status !== 'settled') throw new InvalidStateError();45return await stripeAdapter.executeRefund(tx.providerId, amt);46}

Cross-repository analysis
Traces flows seamlessly across mono-repos and microservices.
Claim-level evidence
Every statement cites commit, file, line, and AST node.
Visible uncertainty
Directly identifies inferred leaps and source disagreements.
Behavioral revision history
Tracks how system behavior changes commit-by-commit.

How Atlas works

From a business question to inspectable evidence.

How Atlas translates distributed systems, asynchronous event flows, and legacy codebases into clear, verified answers.

Build the behavior model

Synthesizes static AST parsing with queue schemas to discover dynamic cross-service dependencies without running heavy production profiling.

auth-serviceAST: token_handler.go:44
gRPC call
api-gatewayRoute: /v2/session
Async dispatch
topic: session.authorizedValidated schema

Natural query

Ask how a feature works

Input natural inquiries regarding rules, transaction boundaries, or state lifecycles.

Query parsed“When can an enterprise account skip 2FA verification?”

Verified

Inspect claims and dependencies

Evaluate assertions backed by verifiable AST pointers, explicit configs, and exact line locations.

Pointerauth/policies/mfa.go:114

+ 1 rule mutated

Track what changes

Every pull request is analyzed to compute behavioral mutations before code merges to production.

PR #1482Flagged for review

Deep inspectability

The behavior graph is the source of truth.

Atlas continuously compiles AST parses, database schemas, synchronous RPCs, and event topologies into a living semantic graph.

Client / UI
Support Portal
v2.19.0 · React
Gateway
Orders API
Go 1.21 · gRPC/REST
Active focusCore Domain
Payments Service
TypeScript · Node 20
Message Queue
Event Bus
Kafka · refund_events

Execution target: StripeRefundAdapter.execute()
Source provenance: payments/src/adapters/stripe.ts
Confidence metric: Direct AST call path

Bi-directional tracing

Navigate from a business rule to exact code lines, or from a pull request diff to the workflows it alters.

Static vs runtime verification

Cross-reference static guarantees with distributed traces without intrusive runtime agents.

Evidence states

Trust comes from showing the work.

Confidence in automated software models must never be an opaque percentage or black box. Atlas categorizes every system claim through an explicit semantic taxonomy paired with provenance.

Verified

Direct executable behavior

Multiple consistent sources or direct executable behavior without unresolved branches.

Direct executable behavior

Supported

One strong source

One strong source with an unambiguous execution path and verified parameters.

One strong source

Inferred

Indirect evidence

Evidence strongly suggests the relationship through naming conventions or schema matches.

Indirect evidence

Conflicted

Sources disagree

Available sources disagree across repositories, specifications, or documentation.

Sources disagree

Unknown

Evidence unavailable

Required information could not be found or repository permissions restrict visibility.

Evidence unavailable

Source A: Code Implementationpayments/rules.ts:18

// Global limit enforced
const MAX_CHARGEBACK_WINDOW_DAYS = 90;

Compiled into runtime assertion in billing validator logic.

Source B: Commercial Terms Markdowndocs/merchant-terms.md:44

"Enterprise tier merchants retain a chargeback review period of up to 120 days from invoice timestamp."

Customer-facing documentation updated 14 days ago by Sales Ops.

Unified understanding

One model. The right depth for every role.

A single unified behavioral model projected into the precise vocabulary needed by leadership, product teams, and engineers.

Projection mode:Lossless semantic abstraction

Business Rule Integrity

Every SLA, customer promise, and financial limit mapped to whether software actually enforces it.

✓ Refund ceiling: $1,000/day
✓ Policy evidence linked

Compliance & Audit

Export audit-ready evidence proving policy enforcement without requesting engineering hours.

Export: Policy Control Evidence
Status: Evidence links available

Exception Management

Track which customer tiers have bypass permissions and unreviewed edge-case triggers.

Known exceptions
Unresolved gaps

Behavior change history

Know what changed in behavior, not just what changed in code.

Code diffs show characters. Atlas shows how real business rules and workflow expectations shift between commits.

PR #1482Author: @marcus-eng

Update auto-refund threshold for tier-1 accounts

base: v2.4.1 → head: v2.5.0

Before (v2.4.1)commit e3ff19c

rule.auto_refund_limit = $250
rule.requires_supervisor = false

Automated instant refund triggered unconditionally for eligible claims under $250.

After (v2.5.0)commit d4a1f62

rule.auto_refund_limit = $500
rule.requires_supervisor = (fraud_score > 0.15)

Limit raised to $500, but introduces a conditional fraud check branch requiring supervisor review.

Impacted nodes:

Orders API
Payments Service
Fraud Engine

2 claims updated · 1 claim added

Merged behavior verified against the master branch. Not yet in production.

Enterprise governance

Private software demands explicit controls.

Atlas will require explicit controls for private repositories and sensitive technical context. Deployment and compliance requirements will be validated with initial customers.

Permission-aware retrieval

Users only receive explanations referencing repositories and branches they explicitly have read access to in GitHub.

Repository access inheritance

Inherits repository permissions directly from GitHub access controls and organization rules.

Secret scrubbing & exclusions

Detect secrets and exclude configured sensitive files and source patterns before analysis begins.

Complete auditability

Detailed logging of every query, view inspection, and citation export to trace software understanding activity.

Tenant isolation & encryption

Dedicated tenant data isolation and encrypted transport for all code indices and semantic graphs.

Configurable model-provider controls

Control which source data may be sent to model providers and define provider-specific handling policies.

Read the security approach

Join the waitlist

Make your software understandable before the next change makes it harder.

Accelerate engineer onboarding, eliminate compliance archaeology, and verify high-stakes refactors with evidence-backed clarity.

Explore the product documentation