Architecture intelligence for complex systems
Before changing one service, know what else you're changing.
Wattra investigates code, contracts, tests, dependencies, configuration, and ADRs across repositories. It shows affected components, risks, and unknowns — then preserves the reviewed result for the next engineer or AI agent.
- Evidence-linked
- Explicit unknowns
- Reviewable memory
- Agent-neutral
One change request. A governed investigation. A reviewable result.
Input & evidence
Change request
Add partial refunds across the payment system.
Evidence sources
- Verified
PaymentController.cs
Code
- Verified
refund-requested.schema.json
Contract
- Inferred
appsettings.Production.json
Configuration
- Unknown
SettlementWorkerTests.cs
Tests
- Stale
ADR: Payment event compatibility
ADR
Architecture investigation
- 01Payments APIVerified
- 02Refund ContractVerified
- 03Event BusInferred
- 04Settlement WorkerInferred
- 05Ledger StoreStale
Result
Open unknown
Legacy reconciliation flow has no confirmed owner.
Compatibility risk
Refund idempotency differs between contract versions.
Impact brief
5
affected components
3
contracts
8
relevant tests
2
open questions
1
compatibility risk
Reviewed result saved to Architecture Memory.
From repeated discovery to reusable architecture knowledge
Without Wattra
- 01Search repositories
- 02Ask senior engineers
- 03Read stale documentation
- 04Build a one-off explanation
- 05Repeat the investigation later
Context remains fragmented across tools, chats, documents, and people.
With Wattra
- 01Investigate evidence
- 02Understand architecture
- 03Expose risks and unknowns
- 04Review the result
- 05Preserve reusable context
Each accepted investigation improves the shared architecture understanding.
One architecture intelligence core. Every engineering decision.
Wattra does not build separate AI features that rediscover the system independently. Investigations, specifications, diagrams, meetings, and external agents work from the same reviewed architecture understanding.
Living Architecture Model
The shared, evidence-backed understanding every application draws from.
Input
A system question or proposed change
Output
Architecture & Impact Brief
5
components
3
contracts
8
tests
2
questions
The starting point. Every other application builds on a reviewed investigation.
One architecture intelligence core. Four critical workflows.
General-purpose AI can help engineers read code faster. Wattra turns that investigation into persistent, evidence-backed, freshness-aware architecture memory — then uses it to support decisions, specifications, diagrams, meetings, and implementation agents.
AI assistants accelerate a session. Wattra preserves and evolves the architectural understanding behind it.
Trace a core change across hundreds of repositories
A change to a shared core component can affect services, contracts, tests, deployment paths, and past architectural decisions across a large repository estate. Wattra investigates the relevant paths, preserves the evidence, and records what is fresh, stale, or still unknown.
Change requirement
What changes if the shared-core event contract evolves?
Repository estate
Scanning…- Confirmed by evidence
- Inferred
- Unknown / needs investigation
- Stale context
Evidence ledger
- shared-core/events/OrderSettled.cs
- order-settled.schema.json
- SettlementConsumerTests.cs
- ADR-021 event versioning
Impact brief · Investigation Session saved
7
affected repos
3
event contracts
12
relevant tests
2
open unknowns
- Fresh
- Changed since investigation
- Needs revalidation
Ad-hoc coding assistant
Re-scan repositories → rebuild context → spend tokens again → receive a point-in-time answer.
Wattra
Investigate → preserve evidence → track freshness → reuse and update architecture memory.
One continuous architecture loop
- Investigate
- Discuss
- Decide
- Specify
- Implement
- Re-index
- Learn
Model-flexible by design. Agentic under the hood. Open at the edges.
Wattra does more than send repository context to a single prompt. It plans an investigation, explores the relevant evidence, evaluates gaps, records findings, and updates persistent architecture memory. Teams can use the result through the Wattra interface, MCP server, or REST API.
The model is replaceable. Repository intelligence is the product.
Choose a local or cloud LLM according to your infrastructure and data boundaries. Wattra orchestrates an iterative, evidence-governed investigation flow and exposes architecture context through MCP and REST.
Consumers
- Engineers
- Architecture teams
- Meeting copilot
- Coding agents
- Internal engineering tools
Interfaces
- Wattra UI
- MCP Server
- REST API
Wattra agentic runtime
Governed loop — repeats until evidence is sufficient
- 1Plan
- 2Inspect
- 3Record evidence
- 4Evaluate gaps
Then conclude
- Conclude
- Generate artifact
- Update memory
Evidence sources
- Source code
- Multiple repositories
- APIs & contracts
- Tests
- ADRs
- Documentation
- Configuration
Living Architecture Model
- Evidence ledger
- Decision memory
- Freshness state
- Investigation artifacts
Outputs
- Impact brief
- Change specification
- User stories & tasks
- Architecture diagrams
- Meeting context
- Context for external agents
Run investigations through a model endpoint in your environment.
Change the model without rebuilding the architecture intelligence layer.
Open at the edges: MCP & REST
MCP Server
Give coding agents evidence-backed architecture context and Wattra tools without manually copying investigation history between sessions.
Coding agent requests
Architecture context for a backlog task
Wattra returns
- Relevant specification
- Affected components
- Architectural constraints
- Source evidence
- Current unknowns
Agent handoff
- 1An external coding agent receives a backlog task
- 2The agent requests architecture context through Wattra MCP
- 3Wattra returns the specification, affected components, constraints, evidence, and unknowns
- 4The agent starts implementation with that context
- 5After the change merges and repositories are re-indexed, Wattra updates the architecture model
External agents consume Wattra's architecture context instead of rediscovering it for every task.
How the layers relate
- Local or cloud model
- Wattra agentic investigation
- Evidence-backed architecture memory
- UI · MCP · REST · Artifacts
The model is an outer, swappable dependency. Wattra's agentic investigation and its evidence-backed architecture memory are the persistent product.
Architecture memory you can inspect, review, and trust
Wattra does not merely answer questions about code. It creates and continuously updates evidence-backed architecture memory that teams and agents can use to investigate, decide, specify, implement, and learn.
Architecture claim
Settlement Worker consumes RefundRequested events.
- Verified — Handler and passing test confirm consumption.
- Inferred — Retry path inferred from configuration.
- Unknown — Dead-letter behaviour is unconfirmed.
- Stale — ADR predates the last contract change.
- Contradicted — Two contract versions disagree.
Wattra keeps facts, assumptions, uncertainty, and stale knowledge visibly different.
How the knowledge stays trustworthy
- Evidence over plausibility
- Explicit uncertainty
- Reviewed and versioned knowledge
- Neutral context for existing agents
- Human review before implementation
Honest product status
- Change-impact investigationCurrent focus
- Spec & agent handoffNext
- Living architecture diagramsNext
- Architecture meeting copilotFuture vision
Roadmap statuses are indicative. Investigation is where Wattra is focused today; the other workflows build on the same architecture memory over time.
Have a change that crosses system boundaries?
We are looking for platform teams and modernization specialists willing to validate Wattra on real architecture investigations and change-impact decisions.