ArchMellon Beta is now open

Speak friend, and enter.

The architecture intelligence platform that builds a living graph of your microservices straight from source code. No YAML. No instrumentation. No drift.

archmellon.graph — order-platform / 14 services discovered
api-gateway auth-svc order-svc payment-svc inventory ledger notify
Detects communication patterns across
Go Python TypeScript JavaScript Rust GitLab GitHub Kafka AMQP gRPC
// THE THIRD PATH

The architecture is already in your code.

You don't need YAML declarations. You don't need OpenTelemetry sidecars. ArchMellon reads what's already there.

01 — INDEX

Deep AST parsing

ArchMellon reads your repositories and builds a complete syntax tree across Go, Python, TypeScript, JavaScript, and Rust. Function calls, routing keys, handlers — every signal captured.

02 — DETECT

WASM plugins

Sandboxed WebAssembly plugins encode your framework's communication patterns. AMQP, gRPC, Kafka, NATS, REST — express the unique shape of your stack as code, run safely against any repo.

03 — UNIFY

Living graph

We connect the dots across repositories into a unified, queryable communication graph. Every commit re-indexes. The catalogue can never rot — because it isn't maintained, it's derived.

order-svc/handlers.go 
// extracted via tree-sitter
func handleOrderCreated(ctx context.Context, o *Order) error {
  if err := o.Validate(); err != nil {
    return fmt.Errorf("validate: %w", err)
  }
  mesh.SendCommand("process_payment", o.ID, o.Total)
  mesh.PublishEvent("order.created", o)
  return nil
}
# amqp-detector.wasm — plugin output
▸ visit_call mesh.SendCommand
  routing_key:  "process_payment"
  protocol:     AMQP
  target:       payment-svc  // resolved cross-repo
  edge:         order-svc → payment-svc
  confidence:   0.97
▸ visit_call mesh.PublishEvent
  topic:        "order.created"
  subscribers:  [ledger, notify, search]
order-svc payment ledger re-indexed at every commit · last: 2s ago
// FEATURES

When a monolith becomes 50 microservices, you lose the map.

ArchMellon is the third path between stale manual catalogues and heavy runtime instrumentation. Built for engineering teams that need ground truth, not approximations.

Zero-maintenance catalogue

Generated directly from source code via AST parsing. Re-indexes on every commit so it never rots. Your service map is as fresh as your last git push.

api orders pay live · last index 2s ago

Static comm detection

Traces full call paths: function → method call → routing key → handler. No runtime sampling required.

WASM plugin system

Express your unique messaging patterns as sandboxed WebAssembly plugins. Hot-reload, signed, multi-tenant.

GitLab-native

Built for self-hosted instances from day one.

SCIP-compatible

Standard symbol indexing, queryable via MCP.

Blast-radius analysis

Know what breaks before you ship.

// COMPARE

Why the third path?

Two well-trodden options. Both fail at scale. ArchMellon takes a different route.

YAML catalogues

Backstage, Cortex, OpsLevel
  • Easy to set up
  • Always out of date
  • Requires team discipline
  • No comm-edge visibility
  • Manual ownership graph
"We'll keep it updated this sprint." — said no team, ever.

Runtime tracing

OpenTelemetry, Datadog APM
  • Reflects actual traffic
  • Heavy instrumentation cost
  • Misses cold paths entirely
  • Sampling-induced gaps
  • Vendor lock-in risk
Great for production. Wrong tool for ground-truth architecture.

ArchMellon

// THE THIRD PATH
  • Static analysis — zero runtime cost
  • Re-indexed every commit
  • Sees every code path, hot or cold
  • Cross-repo edge resolution
  • Self-hosted, your repos stay yours
The architecture is already in your code. We just read it.
// QUESTIONS

Things you're probably wondering.

Pragmatic answers, no hand-waving. If you have more, drop us a line.

No. ArchMellon performs purely static analysis on your source repositories. Nothing is injected, nothing is sampled at runtime, nothing changes about how your services boot or run. We read your code, we don't run it.
Go, Python, TypeScript, JavaScript, and Rust are first-class today. Java and C# are on the near roadmap. The tree-sitter foundation means new languages slot in without redesigning the pipeline.
Through WASM plugins. You write a small detector in any language that compiles to WebAssembly, signing it for your tenant. The plugin runs sandboxed against parsed AST data and emits comm edges. We ship pre-built detectors for AMQP, gRPC, Kafka, NATS, and HTTP — extend, override, or replace any of them.
Yes. ArchMellon was built GitLab-native and self-hosted-first. The desktop app, indexer, and management plane all run inside your network. Source code never leaves your infrastructure.
Different shape of accuracy. Runtime tracing tells you what's hot now; static analysis tells you what's possible. ArchMellon also captures cold paths, error handlers, batch jobs, and seldom-fired endpoints that traces miss. Each detected edge ships with a confidence score so you can see how much we resolved deterministically vs. heuristically.
The full desktop app, the indexer pipeline, system plugins, and an MCP server you can wire into your AI tooling. Beta participants get direct access to the team for plugin authoring, roadmap influence, and a permanent discount when we exit the beta.

Stop guessing your architecture.

Join the beta. Discover your actual communication topology in minutes — not in a quarterly cataloguing project.