requirementAgent — Multi-Domain Requirements Engineering Agent

Production-ready autonomous AI agent for safety-critical requirements engineering across automotive, defence, medtech, and railways domains.

🎯 Overview

requirementAgent is a LangGraph-based multi-agent system that automates the complete requirements engineering lifecycle for mission-critical software systems. It provides mathematically rigorous verification, automated safety analysis, and full bidirectional traceability — all while supporting both local (Ollama, LM Studio) and cloud (NVIDIA NIM, OpenRouter, Anthropic, OpenAI, Cerebras, Groq, Gemini, Azure OpenAI, AWS Bedrock) LLM providers.

Key Capabilities

Capability	Description
EARS Parsing	Syntactic validation, auto-rewrite, and ambiguity detection per Easy Approach to Requirements Syntax
Formal Verification	EARS → LTL/CTL → SMT-LIB v2 → Z3 SMT solver for contradiction detection and edge-case synthesis
Safety Analysis	Automated Functional Hazard Assessment (FHA) per ISO 26262, IEC 62304, EN 50128, DO-178C
Threat Modeling	STRIDE analysis + MITRE ATT&CK mapping + security controls verification
Traceability	Bidirectional SYS.2 ↔ SWE.1 ↔ SWE.2 ↔ SWE.3 ↔ Code ↔ Tests matrices
Multi-Provider LLM	12+ providers with intelligent routing, circuit breakers, and cost control
Four-Tier Memory	Working, Episodic, Semantic (vector+graph), Procedural (CoALA architecture)
Observability	Full Langfuse tracing, evaluation datasets, cost tracking, PII masking
Interoperability	A2A, AGNTCY ACP, OASF schema, OpenWiki documentation
Compliance	EU AI Act (high-risk), EU CRA (Class II), GDPR, ASPICE v4.0

🏗 Architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│                           requirementAgent                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │ Ingest   │→ │ EARS     │→ │ Formal   │→ │ Safety/  │→ │ Trace    │       │
│  │ Node     │  │ Parser   │  │ Verify   │  │ Security │  │ Compiler │       │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘  └──────────┘       │
│       │           │            │            │            │                  │
│       ▼           ▼            ▼            ▼            ▼                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    LangGraph Orchestrator                             │   │
│  │  • State management  • HITL gates  • Checkpointing  • Retry logic    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
├────────────────────────────────────┼────────────────────────────────────────┤
│  LLM Router (12 providers)         │  Memory Manager (4 tiers)             │
│  • OpenAI, Anthropic, Groq         │  • Working (in-context)              │
│  • NVIDIA NIM, Cerebras, Groq      │  • Episodic (vector + time-series)   │
│  • Gemini, Azure OpenAI, Bedrock   │  • Semantic (vector + knowledge graph)│
│  • Ollama, LM Studio (local)       │  • Procedural (skills + heuristics)  │
│                                    │                                        │
├────────────────────────────────────┤
│  Observability                     │  Interoperability                     │
│  • Langfuse (traces, evals, cost)  │  • A2A (Agent2Agent)                 │
│  • OTel export for AGNTCY          │  • ACP (Agent Connect Protocol)      │
│  • PII masking                     │  • OASF (Open Agentic Schema)        │
└────────────────────────────────────┴────────────────────────────────────────┘

📋 Supported Domains & Standards

Domain	Safety Standard	Security Standard	Quality Standard	Criticality Levels
Automotive	ISO 26262	ISO 21434	ASPICE v4.0	QM, ASIL-A–D
Defence/Aerospace	DO-178C, MIL-STD-882E	NIST SP 800-53, CNSSI 1253	IEEE 29148	DAL A–E
Medtech	IEC 62304	FDA Cybersecurity Guidance	ISO 13485	Class A–C
Railways	EN 50128/50657	CLC/TS 50701	CENELEC	SIL 0–4

🚀 Quick Start

Prerequisites

Python 3.11+
Z3 SMT solver (pip install z3-solver)
(Optional) Local LLM: Ollama or LM Studio

Installation

# Clone and install
git clone https://github.com/SoftwareDevLabs/requirementAgent.git
cd requirementAgent
pip install -r requirements.txt

# Install Z3 for formal verification
pip install z3-solver

# Configure environment
cp .env.template .env
# Edit .env with your API keys

Configuration

# config.yml - Key sections
agent:
  name: "requirementAgent"
  version: "1.0.0"
  role: ["provider"]  # EU AI Act role

llm:
  router:
    default_provider: "openrouter"
    task_routing:
      formal_verification: "anthropic:claude-3.5-sonnet"
      ears_parsing: "openrouter:google/gemini-flash-1.5"
      safety_analysis: "openai:gpt-4o"
    fallback_chain: ["openrouter", "anthropic", "openai", "groq", "ollama"]
    cost_budget_usd_per_day: 50.0

memory:
  episodic:
    backend: "postgres-pgvector"
    retention_days: 90
  semantic:
    backend: "mem0"
    graph_backend: "neo4j"

protocols:
  a2a:
    enabled: true
    signed: true
  acp:
    enabled: true

Running

# Start the agent server
python -m src.agents.requirement_agent

# Or run a quick validation
python examples/automotive_braking_example.py

💻 Usage Examples

Basic Requirements Validation

import asyncio
from src.agents.requirement_agent import create_requirement_agent

async def main():
    agent = create_requirement_agent({
        "domain": "automotive",
        "config": {"llm": {"router": {"default_provider": "openrouter"}}}
    })
    
    requirements = [
        {"id": "REQ-001", "text": "The braking system shall apply brakes within 100 milliseconds"},
        {"id": "REQ-002", "text": "When obstacle detected, the collision avoidance system shall initiate emergency braking"},
        {"id": "REQ-003", "text": "While vehicle speed > 10 km/h, the door control shall lock all doors"},
    ]
    
    result = await agent.run(requirements, domain="automotive")
    
    # Access compliance package
    pkg = result["compliance_package"]
    print(f"EARS Compliance: {pkg['compliance_evidence']['ears_compliance_rate']:.1%}")
    print(f"Formal Consistency: {pkg['formal_verification']['is_consistent']}")
    print(f"Hazards Found: {pkg['compliance_evidence']['hazards_identified']}")
    print(f"Threats Found: {pkg['compliance_evidence']['threats_identified']}")

asyncio.run(main())

Streaming with Progress Updates

async for chunk in agent.run_streaming(requirements, domain="medtech"):
    if "current_phase" in chunk:
        print(f"Phase: {chunk['current_phase']}")
    if "compliance_package" in chunk:
        print("✅ Complete!")

Formal Verification Only

from src.pipeline.formal_verifier import create_formal_verifier
from src.pipeline.ears_parser import create_ears_parser

ears = create_ears_parser()
verifier = create_formal_verifier({"timeout_ms": 30000})

# Parse and verify
reqs = [ears.parse("The valve shall remain closed when pressure high")]
validated = [ears.validate(r) for r in reqs]
result = verifier.verify_requirements(validated)

if result.is_consistent:
    print("✅ No contradictions found")
else:
    print(f"❌ Contradiction: {result.unsat_core}")
    print(f"Counterexample: {result.model}")

Safety & Security Audit

from src.pipeline.safety_auditor import create_fh_analyzer, create_threat_analyzer

fha = create_fh_analyzer("automotive")
threat = create_threat_analyzer("automotive")

fha_result = fha.analyze(validated_reqs)
threat_result = threat.analyze(validated_reqs)

print(f"Hazards: {len(fha_result.hazards)}")
print(f"Threats: {len(threat_result.threats)}")
print(f"MITRE Techniques: {list(threat_result.mitre_mapping.keys())}")

📁 Repository Structure

requirementAgent/
├── config.yml                 # Main configuration
├── .env.template              # Environment template
├── requirements.txt           # Python dependencies
├── setup.py                   # Package setup
├── SPEC.md                    # Technical specification
├── CHANGELOG.md               # Version history
├── README.md                  # This file
├── docs/                      # Documentation
│   ├── architecture.md
│   ├── configuration.md
│   ├── deployment.md
│   └── extension.md
├── memory/                    # Domain knowledge bases
│   ├── automotive/
│   ├── defence/
│   ├── medtech/
│   └── railways/
├── src/
│   ├── agents/
│   │   └── requirement_agent.py    # LangGraph orchestrator
│   ├── llm/
│   │   ├── schemas.py              # Message/Tool/Completion types
│   │   ├── router.py               # Intelligent provider routing
│   │   └── providers/              # 12 provider implementations
│   ├── memory/
│   │   ├── __init__.py             # 4-tier memory manager
│   │   ├── working.py              # In-context working memory
│   │   ├── episodic.py             # Vector + time-series
│   │   ├── semantic.py             # Vector + knowledge graph
│   │   └── procedural.py           # Skills + heuristics
│   ├── pipeline/
│   │   ├── ears_parser.py          # EARS syntactic validator
│   │   ├── formal_verifier.py      # LTL→Z3 verification
│   │   ├── safety_auditor.py       # FHA + STRIDE + MITRE
│   │   └── trace_compiler.py       # Bidirectional traceability
│   ├── protocols/
│   │   └── a2a_acp.py              # A2A/ACP/OASF interfaces
│   └── observability/
│       └── langfuse.py             # Tracing, evals, cost tracking
├── tests/
│   ├── unit/
│   │   └── pipeline/               # EARS, formal, safety tests
│   ├── integration/
│   │   └── test_full_pipeline.py   # End-to-end tests
│   └── smoke/                      # Quick health checks
├── examples/
│   ├── automotive_braking_example.py
│   ├── medtech_infusion_pump.py
│   ├── railways_signaling.py
│   └── defence_flight_control.py
└── .github/workflows/              # CI/CD pipelines

🧪 Testing

# Run all tests
pytest

# Unit tests only
pytest tests/unit/

# Integration tests
pytest tests/integration/

# Smoke tests
pytest tests/smoke/

# With coverage
pytest --cov=src --cov-report=html

# Specific test file
pytest tests/unit/pipeline/test_ears_parser.py -v

Test Coverage Targets

Layer	Target
Unit	≥ 85%
Integration	≥ 70%
E2E	≥ 60%

🔧 Configuration Reference

LLM Provider Setup

Provider	Env Var	Base URL	Models
OpenAI	`OPENAI_API_KEY`	`https://api.openai.com/v1`	gpt-4o, gpt-4o-mini, o1
Anthropic	`ANTHROPIC_API_KEY`	`https://api.anthropic.com`	claude-3.5-sonnet, haiku, opus
OpenRouter	`OPENROUTER_API_KEY`	`https://openrouter.ai/api/v1`	300+ models
NVIDIA NIM	`NVIDIA_NIM_API_KEY`	`https://integrate.api.nvidia.com/v1`	Nemotron, Llama
Cerebras	`CEREBRAS_API_KEY`	`https://api.cerebras.ai/v1`	Llama 3.1 70B/405B
Groq	`GROQ_API_KEY`	`https://api.groq.com/openai/v1`	Llama, Mixtral, Gemma
Gemini	`GEMINI_API_KEY`	`https://generativelanguage.googleapis.com`	1.5 Pro/Flash
Azure OpenAI	`AZURE_OPENAI_API_KEY`	`https://{resource}.openai.azure.com`	GPT-4o, GPT-4o-mini
AWS Bedrock	`AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY`	Regional	Claude, Llama, Nova
Ollama	`OLLAMA_BASE_URL` (default: `http://localhost:11434/v1`)	Local	Any GGUF
LM Studio	`LM_STUDIO_BASE_URL` (default: `http://localhost:1234/v1`)	Local	Any GGUF

📦 Deployment

Docker

# Dockerfile included
docker build -t requirementagent .
docker run -p 8000:8000 --env-file .env requirementagent

Kubernetes

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: requirementagent
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: requirementagent
        image: requirementagent:latest
        envFrom:
        - secretRef:
            name: requirementagent-secrets

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Make changes with tests
Run full test suite (pytest)
Submit PR with description

Code Standards

Type hints required for all public APIs
Docstrings in Google style
Line length ≤ 100 chars
Imports sorted: stdlib → third-party → local
Tests required for new functionality

📄 License

Apache 2.0 — See LICENSE.md

🙏 Acknowledgments

Z3 Theorem Prover (Microsoft Research) — Formal verification backbone
LangGraph (LangChain) — Workflow orchestration
Langfuse — Observability platform
EARS (Alistair Mavin) — Requirements syntax standard
CoALA (Sumers et al., Princeton) — Four-tier memory architecture
A2A/ACP/OASF (Linux Foundation/AGNTCY) — Interoperability protocols

📞 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Email: info@softwaredevlabs.com
Documentation: docs/

Built with ❤️ by SoftwareDevLabs for the safety-critical engineering community.

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
.github		.github
build		build
config		config
data		data
doc		doc
examples		examples
frontend		frontend
notebooks		notebooks
oss		oss
res		res
src		src
test		test
tests		tests
tools		tools
.editorconfig		.editorconfig
.env.template		.env.template
.gitattributes		.gitattributes
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
LICENSE.md		LICENSE.md
NOTICE.md		NOTICE.md
README.md		README.md
SECURITY.md		SECURITY.md
SPEC.md		SPEC.md
SUPPORT.md		SUPPORT.md
config.yml		config.yml
metrics.svg		metrics.svg
requirements.txt		requirements.txt
setup.py		setup.py

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

requirementAgent — Multi-Domain Requirements Engineering Agent

🎯 Overview

Key Capabilities

🏗 Architecture

📋 Supported Domains & Standards

🚀 Quick Start

Prerequisites

Installation

Configuration

Running

💻 Usage Examples

Basic Requirements Validation

Streaming with Progress Updates

Formal Verification Only

Safety & Security Audit

📁 Repository Structure

🧪 Testing

Test Coverage Targets

🔧 Configuration Reference

LLM Provider Setup

📦 Deployment

Docker

Kubernetes

🤝 Contributing

Code Standards

📄 License

🙏 Acknowledgments

📞 Support

About

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages