Skip to main content

Introduction

This Architecture Description Document (ADD) specifies the technical architecture for the Deep Evidence Agent (DEA) — an engineering-grade, multi-agent platform for evidence-grounded reasoning, traceability, and impact analysis in safety- and mission-critical engineering organizations.

This ADD reflects and operationalizes the scope defined in the PRD – AURAISON AI in Engineering Platform, and is fully aligned with its engineering focus:

  • Requirements tracing & change impact analysis
  • Design decision justification
  • Standards compliance reporting
  • V&V coverage and evidence management
  • Engineering knowledge capture & reuse

The architecture provides:

  • Multi-agent orchestration specialized for engineering tasks.
  • Retrieval and extraction over engineering artifacts (requirements, design docs, SysML/UML models, code, tests, standards).
  • A provenance and traceability graph enabling full auditability.
  • Human-in-the-loop controls required in regulated engineering domains.

Relationship to the PRD and Traceability

Scope Alignment​

The architecture covers the same engineering-specific scope as defined in the PRD:

  • Engineering workflow automation (PRD Goals G-1, G-2).
  • Evidence-grounded engineering outputs (FR-2, FR-3, FR-4).
  • Traceability and impact analysis workflows (UC-1, FR-4, FR-6).
  • Multi-agent reasoning over engineering artifacts (FR-1, FR-5).
  • Safety, compliance, and auditability (NFR-1, NFR-6, SEC-, PRIV-).
  • Integration with engineering lifecycle tools (FR-7, Data & Dependencies).

PRD → Architecture Traceability Table​

PRD ItemEngineering-Focused DescriptionArchitectural Component / View
FR-1Engineering question decomposition (impact, trace gaps)Planner Agent, Orchestrator (§5.2, §6.2)
FR-2Retrieval across requirements, design docs, code, testsRetrieval Service, Vector DB, Lexical Search (§5.3, §7.2)
FR-3Evidence extraction from engineering artifactsIngestion Pipeline, Artifact Parsers, Evidence Extractor
FR-4Provenance & traceability trackingEvidence Store, Traceability Graph (§5.4, §7.3)
FR-5Multi-agent coordination for engineering workflowsOrchestrator, Agent Runtime, Message Contracts
FR-6Human-in-the-loop engineering reviewSession Manager, Revision Store, UI (§6.4)
FR-7Export & lifecycle tool integrationExport Service, API Gateway (§5.6, §6.5)
FR-8Session & project managementSession Service, State Store (§5.5, §6.3)
NFR-1Accuracy of engineering claims & trace linksCritic Agent, Provenance Graph, Validation Pipelines
NFR-2Latency for engineering queriesModel Serving, Caching, Fast Retrieval
NFR-3Throughput for concurrent engineering sessionsStateless services, scalable infra (§9)
NFR-4Availability for engineering teamsRedundancy, graceful degradation, HA architecture
NFR-5Compute cost for long-running engineering analysesTiered models, batching, token budgets
NFR-6Auditability of engineering sessionsLogging, provenance graph, audit streams
NFR-7Interpretability of engineering rationalePlanner/Critic rationales, trace graph visualizations
**SEC-, PRIV- **Engineering data security & complianceRBAC, isolation, encryption, policy engine (§10)

Stakeholders & Engineering Concerns

Stakeholders​

  • Systems / Design Engineers — decisions & tradeoffs must be traceable to requirements.
  • Verification & Validation Engineers — need coverage and test-to-requirements alignment.
  • Requirements / PLM Engineers — maintain consistency and traceability across lifecycle.
  • Engineering Managers & Product Managers — need impact analyses and evidence for decisions.
  • Compliance / QA — require audit trails for standards (e.g., DO-178C, ISO 26262).
  • Security / IT / Architecture — enforce safe, compliant model & data usage policies.
  • ML Platform / Data Platform — provide infrastructure for LLMs, document access, indexing.

Key Architectural Concerns (Engineering-Focused)​

  • High trust & evidence validity (NFR-1, NFR-6).
  • Deep traceability across engineering artifacts (FR-4).
  • Predictable performance for large engineering corpora (NFR-2).
  • Integration with lifecycle tools (DOORS, Jama, Jira, Git, test systems) (FR-7).
  • Multi-tenant isolation for different engineering programs (SEC-3).
  • Compliance with regulated engineering standards (PRIV-, SEC-).

System Context View (Engineering Edition)

Actors and systems now fully match the engineering domain.

Logical Architecture View (Revised)

High-Level Component Structure​

Component Responsibilities (Engineering Version)​

Engineering Interfaces​

  • Domain-specific UI elements:

    • Trace graphs
    • Impact analysis visualizer
    • Evidence browser
    • DOORS-style trace matrix export

Orchestrator & Planner (FR-1, FR-5)​

  • Accepts engineering questions (e.g., “Impact of REQ-123?”).

  • Builds task DAG specialized for engineering workflows:

    • Requirement lookups
    • Design model checks
    • Code reviewers
    • Test coverage retrieval

Engineering Agent Runtime​

  • Researcher Agent:

    • Searches engineering artifacts across lifecycle systems.

  • Critic Agent:

    • Validates evidence links in traceability graph.
    • Detects inconsistent requirements, ambiguous design sections.

  • Synthesizer Agent:

    • Produces trace matrices, impact summaries, design decision documents.

Retrieval Service (FR-2)​

Connectors for:

  • DOORS/ReqIF / Jama / Polarion
  • Source code repos (AST parsing + embeddings)
  • Design docs (Confluence, SharePoint)
  • SysML/UML/Simulink model repositories
  • Test systems and CI logs
  • Standards libraries

Ingestion & Parsing (FR-3)​

Engineering parsers include:

  • Requirements format converters (ReqIF, DOORS XML)
  • Design doc OCR/Markdown/HTML extraction
  • SysML/UML metadata extraction
  • Code AST parsing for module/function-level evidence
  • Test log parsers

Traceability & Provenance Graph (FR-4)​

Nodes:

  • Requirement
  • Design Element
  • Code Component
  • Test Case
  • Evidence Unit
  • Claim

Edges:

  • implements
  • verifies
  • tested_by
  • supported_by
  • conflicts_with
  • derived_from

Process / Behavioral View (Updated)

Traceability Workflow (UC-1)​

This matches PRD UC-1 precisely.

Data / Knowledge View (Engineering Edition)

Artifact Ingestion Model​

Artifact TypeIngestion PathParserNotes
Requirements (DOORS, ReqIF, Jama)API / XML / ReqIFReqIF parserWith hierarchy & IDs
SysML/UML modelsModel reposXMI parser / Model extractorsExtract block definitions, interfaces
Design docsConfluence / SharePoint / GitHTML/Markdown/PDF parsersMaintains section anchors
CodeGit reposAST parsers for major languagesMaps code functions to requirements
TestsTestRail / Jira / CI logsStructured log parsersIdentifies pass/fail & coverage
StandardsInternal libraryPDF parserCitation anchors

Traceability Graph Schema (Revised)​

Requirement:
  id: string
  text: string
  source: "DOORS" | "ReqIF" | ...
  version: string

DesignElement:
  id: string
  doc_path: string
  section: string

CodeComponent:
  repo: string
  file: string
  symbol: string

TestCase:
  id: string
  tool: string
  status: pass|fail|unknown

Edges:
  implements: Requirement -> CodeComponent
  derives_from: DesignElement -> Requirement
  verifies: TestCase -> Requirement
  affects: Requirement -> DesignElement

Quality, Performance & Safety View

Accuracy Assurance (NFR-1)​

  • Enforce claim → evidence relationships before allowing acceptance.

  • Critic detects:

    • Missing evidence
    • Contradictory design sections
    • Ambiguous requirements

Performance (NFR-2, NFR-3)​

  • Partial retrieval caching for common requirements.

  • Graph indexing for fast impact queries.

  • Tiered model invocation:

    • Small models for filtering
    • Medium models for extraction
    • Large models only for synthesis

Auditability & Explainability (NFR-6, NFR-7)​

  • Every design decision doc export is reproducible:

    • Same inputs
    • Same evidence IDs
    • Same trace graph

Deployment View (Engineering)

Updated connectors:

  • Lifecycle Tools Connectors Layer:

    • DOORS/ReqIF
    • Jama
    • Polarion
    • Jira/XRay
    • Git/GitHub/GitLab
    • TestRail
    • PDF standards library

Kubernetes-based deployment with strict network zoning for regulated engineering projects.

Security, Privacy & Governance

Fully aligned with engineering constraints:

  • Mandatory RBAC + project/tenant isolation.

  • Policy engine enforces:

    • No external web retrieval for regulated projects.
    • Only approved models (regulated ML baseline).

  • Sensitive artifacts never leave secure zone.

  • Trace logs kept according to project-level retention policies.

Architectural Decisions (Revised for Engineering)

IDDecisionRationale (Engineering Focus)Alternatives
AD-1Multi-agent orchestrationClear separation between planning, retrieval, V&V, synthesis tasksSingle LLM
AD-2Hybrid retrieval for engineering artifactsRequirements, code, tests require different retrieval modesVector-only
AD-3Traceability graph as core storageMandatory for safety-critical engineering auditabilityFlat files
AD-4Engineering connectors (DOORS, SysML, CI logs)Required for end-to-end lifecycle evidenceManual ingestion
AD-5Strong policy enforcement & zoningNeeded for regulated engineering domainsOpen scripts
AD-6Session-based workflow modelEngineering reviews require iterative refinementStateless chat

Risks (Architecture Perspective)

IDArchitectural RiskImpact (Engineering)Mitigation
AR-1Incomplete coverage of engineering toolsHighPrioritize DOORS, Git, major test tools first
AR-2Poor evidence extraction from modelsHighModel parsing adapters, fallback to human review
AR-3Misconfigured lifecycle connectorsHighEnd-to-end validation & health checks
AR-4Overuse of large models increases costMediumTiered inference + budgets
AR-5Trace graph inconsistencyHighGraph validation and critic agent

Evolution Roadmap

Matches PRD roadmap but engineering-specific:

  • Phase 1 — Trace matrix generation; DOORS + Git + Test connectors.
  • Phase 2 — Full multi-agent engineering reasoning; impact analysis; standards integration.
  • Phase 3 — Domain-specific models (telecom, aerospace, automotive).
  • Phase 4 — Advanced causal engineering reasoning & lifecycle automation.

Appendix

Glossary updated to engineering terminology.