Portfolio · AI platforms

Mohammadreza “Hamid” Matiny

AI Infrastructure & MLOps Engineer specializing in LLM serving, GPU orchestration, and production observability.

Currently: Shipping AI infrastructure, agentic systems, and data platforms across 11 core repositories.

Platform engineering for models that have to ship.

I’m Mohammadreza (“Hamid”) Matiny — an AI infrastructure and MLOps engineer with 4 years across deep learning systems, data pipelines, software backend systems, and cloud infrastructure on GCP and AWS. My work sits where model code meets the platform: serving contracts, GPU scheduling, experiment provenance, and the observability that makes production behavior trustworthy.

Today I build AI platform infrastructure — LLM serving, GPU orchestration, fleet telemetry, and computer-vision pipelines — alongside agentic systems (an A2A multi-vendor agent exchange with signed cards, admission exams and deterministic quarantine; a multi-agent data-incident responder with a deterministic verifier and a Slack approval gate) and agentic-AI security work (policy-as-code gateways, tool-abuse controls, audit trails). That work spans 11 core repositories, 4 of them production-shaped platforms with real CI/CD and Terraform-provisioned infrastructure — and where it matters, measured results instead of estimates: one lakehouse run processed 42,972 records at a 91.8% acceptance rate with zero post-gate rejections, a 72-case incident benchmark recorded 0/27 false fixes, and on a frozen 100-case agent-exchange benchmark the trust layer held attack-caused harm to 2/100 against 64/100 without it.

I care about honest maturity signals: tagged releases when they’re real, architecture diagrams that match the repo, and metrics that come from measured runs — not marketing copy.

4 years Deep learning systems, data pipelines, software backend, and cloud infrastructure
4 platforms Production-shaped systems: multi-backend LLM serving, streaming lakehouses, CV detection
11 core repos LLM infra, agentic systems and agent security, data engineering, and computer vision

Case studies, not just repos.

Architecture, engineering decisions, and honest maturity — verified against public GitHub sources.

BOURSE

Active on main

A2A v1.0 multi-vendor agent exchange — signed Agent Cards with pinned vendor keys, admission exams, a broker that picks agents by measured cost and reliability, deterministic quarantine, and an adversarial benchmark reported as n/N.

Tagged v1.0.0 — Phases 0–7 complete. 871 unit + 29 DB tests with CI green, 54 ADRs, a 17-service Compose stack plus 15 adversary agents, and 1 CI workflow; results are generated from tracked data and CI fails on drift. Frozen 100-case test split, Wilson 95% CIs: with adversaries in the pool, attack-caused harm 2/100 with the trust layer vs 64/100 without it, grader pass 83/100 vs 69/100; a 21-row attack suite caught 18/21 with 0/21 missed. Caveats: a quiet sleeper caused 6/14 harmed tasks before a canary caught it; on an honest-only pool the broker is 15% cheaper and 18% faster than random selection but not more accurate (85/100 vs 88/100); one local model on one machine.

Architecture

Vendors publish Agent Cards signed with JWS over RFC 8785 canonical JSON; the registry verifies them only against a JWKS pinned at onboarding, lints card text, runs a 5-task admission exam per skill, and stores every revision immutably. A LangGraph broker splits a dataset-intake job into typed subtasks and delegates each over A2A to the agent with the best expected utility (reliability lower bound minus cost and latency). Agents built on LangGraph, CrewAI and plain a2a-sdk use their own MCP tools; every LLM call goes through a metering proxy with per-task budgets, fair-share gating and a hard token cap in front of local Ollama models. Spot checks, canaries, an egress DNS sinkhole and usage-misreport checks feed a deterministic trust engine (HARD violations quarantine at once, SOFT ones count k=3 strikes per reliability epoch). Reinstatement needs a fresh exam plus a Slack approval from an allowlisted operator.

Key decisions

  • Card signatures only prove who published a card — admission exams and measured outcomes decide whether an agent is listed and chosen (ADR-0023, ADR-0037)
  • Safety decisions are code, never an LLM; card free text never reaches the selector, so a poisoned card was neutralised by design with outputs matching honest 76/76 (ADR-0008)
  • Strikes are counted per reliability epoch, so reinstatement is a real fresh start, proven live with a re-catch after a Slack approval (ADR-0039, ADR-0048)
  • Exam faults are attributed from meter evidence, so a stalling agent fails its exam instead of hiding behind "infrastructure timeout" (ADR-0049)
  • One outcome function with written rules (caught / missed / ineffective / not exposed / error) and ablations that remove one control at a time: without the sinkhole exfiltration harm was 9/9, without card signatures A1–A3 got through (ADR-0053)
  • Frozen test manifest, clean-worktree --final lock and results generated from data; limits published, including the quiet adversaries the spot checks could not see (ADR-0051, ADR-0054)
  • A2A v1.0
  • MCP
  • LangGraph
  • CrewAI
  • JWS / JCS (RFC 8785)
  • Pydantic
  • Ollama
  • Slack Bolt
  • PostgreSQL
  • Alembic
  • OpenTelemetry
  • Docker Compose

System shape

BOURSE agent exchange Vendors publish signed Agent Cards to the registry, which verifies them against pinned keys, lints card text and runs an admission exam. The broker splits a job into subtasks and delegates each over A2A to the agent with the best measured reliability, cost and latency. Agents use their own MCP tools and call local models through a metering proxy with per-task budgets. Spot checks, canaries, an egress sinkhole and misreport checks feed a deterministic trust engine that quarantines agents. Reinstatement needs a fresh exam and a Slack approval. Vendors JWS-signed Agent Cards Registry pinned JWKS · lint · exam Broker LangGraph · utility select A2A Agents 5 honest · 15 adversaries MCP tools table · pii · units Meter budgets · cap → Ollama Trust engine spot checks · canaries · sinkhole Quarantine k=3 strikes per epoch Slack approval re-exam + human gate reinstate

View repository →

Vulcan

Active on main

Multi-backend LLM serving and GPU-orchestration platform — one contract across vLLM, Triton, Ray Serve, KServe, and BentoML.

Tagged v1.2.0 across 22 phases: advanced GPU serving (GPTQ/AWQ/FP8, TensorRT-LLM templates), cost-per-token tracking, training backends, LoRA/PEFT, DVC exports, pluggable MLflow/W&B tracking, and a tool-grounded LangGraph advisor with non-fabrication CI.

Architecture

Clients and a LangGraph advisor hit a routing gateway that speaks a unified model-serving contract (/health, /metrics, /v1/infer). Backends — BentoML, Ray Serve, Triton (+ TensorRT-LLM), vLLM (+ GPTQ/AWQ/FP8 packs), KServe — plug in behind that contract. Training jobs (Ray Train, FSDP/DDP, DeepSpeed, LoRA/PEFT) share a TrainingJobSpec; MLflow and W&B track runs; DVC versions exports. GPU infra (Kueue / Karpenter / MIG) is validated in CI without burning real GPU cost. SageMaker and Bedrock are selectable managed paths. Observability (Prometheus, Grafana, Tempo, cost-per-token) grounds every advisor number in real evidence.

Key decisions

  • Unified serving contract instead of per-backend APIs (ADR-001)
  • GPU cost-safety: validate-only infra in CI; no invented tokens/s (ADR-002, ADR-007)
  • Kueue multi-tenant scheduling + MIG partitioning strategy (ADR-003, ADR-004)
  • LangGraph advisor is tool-grounded — every stated number must appear in Prometheus/benchmark evidence (ADR-014)
  • Pluggable experiment tracking: MLflow self-hosted + W&B offline-only in CI (ADR-013)
  • vLLM
  • Triton
  • Ray Serve
  • KServe
  • BentoML
  • Kueue
  • Karpenter
  • TensorRT-LLM
  • LoRA/PEFT
  • DVC
  • MLflow
  • W&B
  • LangGraph
  • SageMaker
  • Bedrock

System shape

Vulcan architecture Clients and LangGraph advisor connect to a gateway and model-serving contract, which fans out to BentoML, Ray Serve, Triton, vLLM, and KServe. Training, GPU infra, and observability feed the same system. Clients console / API Gateway routing :9007 Advisor · LangGraph tool-grounded only Model serving contract /health · /metrics · /v1/infer BentoML Ray Serve Triton + TRT-LLM vLLM GPTQ/AWQ/FP8 KServe Training contract Ray · FSDP · LoRA Tracking + DVC MLflow · W&B GPU · Kueue/Karpenter/MIG Observability Managed SM · Bedrock

View repository →

Argus

Active on main

Production-shaped fleet telemetry platform — Kafka/Ray/Flink ingest, Iceberg + Dagster lakehouse, drift detection, OPA-backed incidents, and a read-only AI copilot.

Tagged v1.0.0 — CHANGELOG calls it the first production-shaped release (Phases 0–15). 32 Docker Compose services, 40 test files (including Kafka integration tests) plus e2e chaos, smoke, and k6 load scripts, and 6 active CI workflows (ci, docker-build, semgrep, e2e-nightly, load-nightly, chaos-nightly).

Architecture

Redpanda/MSK → Ray ingest → stream-processor QA gate (Flink option) → Iceberg + Trino lakehouse → Dagster/MLflow orchestration → drift-monitor (KS tests, embeddings, Evidently) → OPA-backed incident-engine (circuit breakers) → api-gateway (OIDC/Keycloak, OPA RBAC) → Next.js dashboard, plus a read-only Qdrant-RAG AI copilot with its own eval harness. Same container images run via Docker Compose locally or Terraform + Helm (one chart per service) + Argo CD app-of-apps on EKS.

Key decisions

  • Contract-first streaming path with an explicit QA gate before lakehouse writes
  • Iceberg + Dagster for reproducible lakehouse materialization
  • OPA policy for incident decisions — not prompt-only automation
  • Copilot is read-only against telemetry and runbooks, backed by an eval harness
  • Documented scope cuts (KNOWN_GAPS.md) instead of overclaiming — no service mesh/mTLS, Vault-backed secrets, or column-level lineage yet
  • Kafka
  • Redpanda
  • Ray
  • Flink
  • Iceberg
  • Trino
  • Dagster
  • OpenTelemetry
  • OPA
  • Argo CD
  • Terraform
  • Next.js
  • Qdrant

System shape

Argus pipeline architecture Streaming path from Kafka or Redpanda through Ray, Flink QA, Iceberg lakehouse, Dagster, drift monitor, incident engine, OpenTelemetry, dashboard, and AI copilot. Kafka / Redpanda Ray Flink QA gate Iceberg lakehouse Dagster Drift monitor Incident engine · OPA OpenTelemetry Dashboard AI copilot

View repository →

PRISM

Active on main

Multi-warehouse fleet-intelligence platform — camera/sensor ingest, a PySpark lakehouse with dbt gold models, and OpenCV/ONNX defect detection with human review.

Tagged v1.2.0 — all 20 phases (0–19) complete, including a golden-path chaos e2e test against the live Compose stack. 17-service Docker Compose stack, 19 test files, 2 CI workflows (lint/test, Terraform validate + release packaging).

Architecture

Camera/sensor ingest lands in a bronze zone, then splits: a PySpark medallion lakehouse (bronze → silver → gold, dbt-modeled) on one side, an OpenCV/ONNX YOLO-family CV service on the other, routing low-confidence findings to a Django control-plane review queue. Gold data fans out through one activation contract to both Redshift and Snowflake, mirrors to Azure Databricks/ADLS for DR, and feeds a Vue 3 + Three.js digital-twin cockpit. An incident-engine runs per-asset circuit breakers on OPA/Rego trip policies; Dagster orchestrates the lakehouse and drift-monitor; a tool-grounded AI copilot answers only from evidence it can cite.

Key decisions

  • Two-layer Pydantic → Pandera validation gate before any bronze promotion
  • Per-asset circuit breakers driven by OPA/Rego trip policies, not hardcoded thresholds
  • Drift-monitor baselines never build from synthetic scenario data — health stays non-ready until a real baseline earns it
  • Copilot is tool-grounded — every answer must cite real evidence (ADR-004)
  • Cloud paths (AWS + Azure Terraform) are plan/validate/checkov-only in CI; human apply only (ADR-001)
  • PySpark
  • Databricks
  • dbt
  • OpenCV
  • ONNX / YOLO
  • Django
  • Vue 3 + Three.js
  • OPA / Rego
  • Dagster
  • Terraform
  • Snowflake
  • Redshift

System shape

PRISM architecture Fleet ingest into a bronze zone, splitting into an OpenCV/ONNX CV service with human review and a PySpark lakehouse with dbt gold models, both feeding a control plane and activation gateway that serve Redshift, Snowflake, a digital-twin cockpit, and an AI copilot. Fleet ingest Bronze zone CV service OpenCV + ONNX/YOLO PySpark lakehouse bronze → silver → gold Review queue Gold · dbt models Control plane Django + RBAC Activation gateway → Redshift + Snowflake Cockpit + AI copilot

View repository →

FORGE

Active on main

Offline AV perception & auto-labeling platform — 2D/3D detection, tracking, sensor fusion, and active-learning pseudo-labeling over a versioned Parquet data lake.

Tagged v0.2.0 — all 11 phases complete (ingest through visualize plus productionization). 15 test files, 2 CI workflows. Detection heads are randomly initialized research baselines, not trained on real labels — documented honestly in KNOWN_GAPS.md rather than overclaimed.

Architecture

The forge CLI runs an 8-stage pipeline end to end locally: ingest (nuScenes → Parquet lake, DVC, Hydra configs) → detect2d (Faster R-CNN) and detect3d (PointNet-style) → track (SORT: Kalman + Hungarian IoU) → fuse (calibrated projection + IoU) → label (trust scoring + active learning) → evaluate (BEV distance, mAP against held-out ground truth) → curate (LanceDB dedup) → visualize (rerun.io / Foxglove MCAP). A parallel cloud path — S3 → Lambda → SQS → DynamoDB → EventBridge → Step Functions → ECS Fargate → Glue (11 tables) → Athena — is Terraform-defined and structurally verified in CI, but intentionally never applied against live AWS.

Key decisions

  • Ground-truth labels used only for evaluation, never as a pipeline input — no label leakage
  • Every pipeline stage round-trips through a versioned Parquet lake instead of ad hoc intermediate files
  • Cloud orchestration built and CI-verified as code, deliberately never deployed — same cost-safety policy as Vulcan, PRISM, and hydra-data-factory
  • Ray distributed execution wired for the two heaviest stages (detect2d/detect3d); the rest run local by design
  • Random-init detectors are labeled as smoke-tested baselines, not tuned models — no inflated accuracy claims
  • PyTorch Lightning
  • Faster R-CNN
  • SORT
  • Ray
  • LanceDB
  • MLflow
  • W&B
  • DVC
  • Hydra
  • Terraform
  • Parquet

System shape

FORGE architecture Local pipeline from ingest through 2D and 3D detection, tracking, sensor fusion, active-learning labeling, then evaluation, curation, and visualization. A parallel cloud infrastructure path is Terraform-verified but never deployed against live AWS. nuScenes → Parquet Cloud infra Terraform · verified, never applied detect2d Faster R-CNN detect3d PointNet-style track SORT: Kalman + IoU fuse calibrated projection label trust scoring + active learning evaluate · mAP vs GT curate · LanceDB dedup visualize · rerun/MCAP

View repository →

aegis

Active on main

AI-native defense-in-depth gateway for LLM apps and agents — prompt injection, data exfiltration, and tool/MCP abuse, with a tamper-evident audit trail.

Tagged v0.6.0 — all 12 build-order stages plus a second hardening pass (stages A–D) complete. 14-service Docker Compose stack, 89 test files, 4 CI workflows (ci, release, security, arm-auto-merge). Publishes its own adaptive red-team result instead of a vendor catch-rate demo, reporting round-1 and adaptive bypass rates separately: real-model hardening cuts round-1 bypass rate (10.8% → 9.2%), while by round 3 of an adaptive campaign bypass rate is 72.8% → 75.0%.

Architecture

A Go gateway fronts the defended chat pipeline: requests pass through Python input-defense detectors, a Go policy-engine evaluating CEL policy packs, and a provider-agnostic Go model-router, then Python output-defense detectors (plus an LLM judge) before any response is released. A separate agent-gate (Go) enforces tool/MCP call permissions with taint tracking. Every enforcement decision is Ed25519-signed into a Postgres-backed audit trail. A continuous red-team engine runs adaptive campaigns directly against input/output defense — deliberately bypassing policy-engine — and publishes bypass-rate evidence to a React/TS dashboard.

Key decisions

  • Security decisions fail closed (gateway/policy-engine/agent-gate outage returns 502, never releases an unchecked response) — only observability fails open, documented explicitly in FAILURE_MODES.md
  • No static default credentials anywhere in the repo — dashboard and gateway keys are generated at container startup or via a credential script
  • Publishes its own adaptive red-team bypass rates honestly, including the unflattering result that hardening barely moves sustained bypass rate — continuous monitoring over a one-time "solved" claim
  • Red-team probes input/output defense directly, deliberately bypassing policy-engine, to measure detector effectiveness in isolation
  • Tamper-evident audit trail via Ed25519-signed receipts, not plain logs
  • Go
  • Python
  • TypeScript
  • CEL policy-as-code
  • Prompt-Guard
  • Toxic-BERT
  • spaCy NER
  • PostgreSQL
  • Redis
  • React

System shape

aegis architecture A Go gateway routes requests through input defense, a CEL policy engine, and a model router before output defense releases a response. A parallel agent-gate enforces tool permissions. Every decision is signed into an audit trail shown on a dashboard, while a red-team engine continuously probes input and output defense directly. App / SDK Gateway (Go) Input defense Python detectors Policy engine Go + CEL Model router provider-agnostic Agent-gate tool / MCP taint Output defense detectors + judge Audit Ed25519-signed receipts Dashboard Red-team engine adaptive campaigns

View repository →

MERIDIAN

Active on main

Multi-agent data-incident response on LangGraph — detects a pipeline data-quality failure, finds the root cause with MCP tools, writes and verifies a sandboxed fix, and holds it for human approval in Slack.

Tagged v1.0.1 — Phases 0–7 complete. 558 offline tests with CI green on Linux, a 9-node LangGraph state machine, 3 MCP servers, and 1 CI workflow. On a 72-case synthetic benchmark: 72/72 detection, 71/72 causal accuracy, 0/27 false fixes, 0/30 hard-mode false positives, and the deterministic verifier blocked 16/16 bad patches the LLM critic approved. $0.00 on local models. Caveat: synthetic benchmark; fix attempts exhausted on 26/72 cases.

Architecture

A fixed LangGraph state machine, not an open-ended agent chat. Sentinel runs pandera contracts over partitions on Ray and emits a typed Incident. Triage sets severity and blast radius; RootCause queries three read-only MCP servers (lineage, data, history) and writes a Hypothesis whose evidence must cite refs the tools returned. Fix writes a Patch (repair, quarantine, rerun upstream, or escalate) plus a pandera regression test; a pre-critic dry run and a second-model Critic review it for up to 3 rounds. A deterministic Verifier replays the failing partition in a Ray sandbox and returns to Fix for up to 3 attempts. SlackApproval interrupts the graph until an allowlisted person approves; a Postmortem and a hash-chained audit log in Postgres record the outcome. Live runs default to local Ollama models.

Key decisions

  • Deterministic state machine with hard loop caps — loop exhaustion is a recorded outcome, not an accident (ADR-001)
  • The verifier is code, not a model: 16 bad patches the LLM critic approved were blocked before reaching a human (ADR-005, ADR-021)
  • Grounding guardrail drops any cited event the MCP tools never returned (ADR-016)
  • Untrusted remediation code runs behind an AST import gate in a Ray worker with a cleared environment (ADR-019)
  • Free local models first; paid providers off unless explicitly enabled with a USD cap, and billing or quota errors stop the run (ADR-023, ADR-024)
  • Benchmark reports n/N with its caveats published: synthetic data, an easy evidence world (48/72 single candidate), and fix attempts exhausted on 26/72 cases (ADR-033)
  • LangGraph
  • LangChain
  • MCP
  • Pydantic
  • pandera
  • Ray
  • Ollama
  • Slack Bolt
  • OpenTelemetry
  • PostgreSQL
  • Alembic
  • Docker Compose

System shape

MERIDIAN agent graph A fixed LangGraph state machine. Sentinel runs pandera contracts on Ray and emits an incident. Triage sets severity, root cause queries three MCP servers, and fix writes a patch with a regression test. A pre-critic dry run and a second-model critic review the patch, with up to three critic rounds. A deterministic verifier replays the failing partition in a sandbox, returning to fix for up to three attempts. Slack approval holds the patch for a human, then a postmortem is written. Sentinel pandera on Ray Triage severity · blast radius Root cause 3 MCP servers Fix patch + regression test Pre-critic sandbox dry run Critic second model rejected · up to 3 rounds Verifier deterministic replay failed · up to 3 fix attempts Slack approval human gate Postmortem report + audit chain

View repository →

Production-validated AV telemetry lakehouse — contract validation, DLQ isolation, Terraform-provisioned AWS path.

Production-validated pipeline with measured run results: 42,972 records ingested · 91.8% acceptance · 0% post-gate rejections.

Architecture

Ingest mock fleet JSON → Pydantic + Pandera contract validation with DLQ isolation for rejects → PyArrow/Parquet (Snappy, Hive partitioning) into S3 → Glue catalog. Dual orchestration: local Airflow + MLflow, and AWS Step Functions + Lambda. Infra fully provisioned with Terraform (S3, Glue, IAM).

Key decisions

  • Dual-path orchestration (Airflow local / Step Functions cloud) sharing one transformation core
  • Hard contract gate with DLQ isolation — rejects never contaminate the lake
  • Hive-partitioned Parquet for query-friendly AV telemetry
  • Everything provisioned as Terraform — no console-only resources
  • Pydantic
  • Pandera
  • PyArrow
  • Parquet
  • Terraform
  • S3
  • Glue
  • Airflow
  • Step Functions
  • MLflow

System shape

hydra-data-factory architecture Fleet JSON ingest through Pydantic and Pandera validation with DLQ isolation, then Parquet to S3 with Glue catalog, orchestrated by Airflow or Step Functions via Terraform. Fleet JSON ingest Pydantic + Pandera contract gate DLQ isolation Parquet · Hive S3 + Glue Airflow + MLflow Step Functions Terraform

View repository →

Where the work actually concentrates.

Drawn from 11 core repositories spanning LLM infra, agentic systems and agent security, data engineering, and computer vision — organized by the systems I ship, not an exhaustive badge wall.

LLM Serving & Inference

  • vLLM
  • Triton Inference Server
  • TensorRT-LLM
  • Ray Serve
  • KServe
  • BentoML
  • GPTQ / AWQ / FP8
  • LoRA / PEFT
  • Bedrock
  • SageMaker

GPU Orchestration & Cloud

  • Kubernetes
  • Kueue
  • Karpenter
  • NVIDIA MIG
  • AWS
  • GCP
  • Terraform
  • Helm
  • Argo CD
  • Docker

MLOps & Experiment Tracking

  • MLflow
  • Weights & Biases
  • DVC
  • GitHub Actions
  • Dagster
  • Kubeflow
  • Prometheus
  • Grafana
  • OpenTelemetry

Computer Vision & Perception

  • OpenCV
  • ONNX
  • YOLO / ByteTrack
  • 2D/3D detection & tracking
  • Sensor fusion (radar / LiDAR / camera)
  • PyTorch
  • Active learning / pseudo-labeling
  • Edge AI

Data & Streaming Systems

  • Kafka / Redpanda
  • Apache Flink
  • Apache Iceberg
  • PyArrow / Parquet
  • Pandera
  • Pydantic
  • Airflow
  • Step Functions
  • Ray
  • PySpark / Databricks
  • dbt

Agentic AI & LLM Security

  • LangGraph
  • LangChain
  • Model Context Protocol (MCP)
  • Agent-to-Agent protocol (A2A)
  • JWS-signed Agent Cards (RFC 8785)
  • CrewAI
  • Multi-agent state machines
  • Human-in-the-loop approval
  • LLM evaluation & benchmarks (n/N, Wilson CIs)
  • Adversarial agent benchmarks & ablations
  • Ollama (local LLMs)
  • PydanticAI
  • Temporal
  • Prompt-injection defense
  • Policy-as-code (OPA)
  • Tamper-evident audit trails
  • Red-teaming patterns

Let’s talk platforms.

Open to conversations about AI infrastructure, LLM serving, MLOps platforms, and agentic security — especially roles where production reliability matters as much as model quality.

Available globally · open to remote