Skip to content

Active Labs

Applied research repositories, prototypes, and engineering utilities under active development.

This section documents applied research and engineering prototypes across data systems and production AI. These projects originate directly from architectural patterns and operational challenges encountered during production client engagements — serving to test low-latency architectures, optimize token and compute costs, and validate design patterns before introducing them into production environments.

Each project functions as an applied research repository focused on benchmarking, architectural validation, and empirical measurement.

Project Availability

While client production code remains strictly confidential, the underlying architectural patterns, benchmark harnesses, and open-source prototypes are incubated here in Active Labs. Technical notes and reference blueprints are published as they mature.

Engineering Foundation

Applied research is guided by an architectural baseline ensuring that local benchmarking translates directly to production deployments.

Architectural Principles

ADR Principle What it commits to
001 Open Source First Every system stays deployable without a mandatory cloud dependency, so experimentation never waits on a provider.
002 Local First Development, validation, benchmarking and experimentation happen locally before anything reaches staging.
003 Cloud Portable Architectures stay portable between GCP (primary) and AWS (secondary) — no single-vendor lock-in by construction.
004 Evaluation Before Deployment Agentic workflows pass systematic regression testing and benchmarking before they ship.
005 Human-in-the-Loop AI proposes actions and drafts artifacts; a human keeps final approval authority.
006 Cost-Aware AI Inference actively optimizes the trade-off between cost, latency, reliability and quality, and measures it.

Technology Strategy

Layer Stack & Tools Architectural Role
Core Languages Python 3.14 (free-threaded where it pays), Rust High-performance routers, data engines, and agent runtimes
Storage & Table Formats Apache Iceberg v3 (deletion vectors, row lineage, variant type), DuckLake, Lance, Parquet, PostgreSQL, LanceDB, Qdrant, LadybugDB Open lakehouse tables, columnar vectors, and graph context
Processing & Modeling Polars, Apache DataFusion, DuckDB, dbt Core 2 (Fusion engine), SQLMesh (Medallion layers) Local-to-cloud vectorized transformation and analytical modeling
Streaming & Ingestion (CDC) Apache Kafka 4 (KRaft) / Redpanda, Apache Fluss, Debezium 3, REST extractors Event streaming, real-time CDC, and raw ingestion pipelines
Orchestration Dagster, Apache Airflow 3 (asset-aware scheduling), Docker Compose Asset-based DAG execution, pipeline dependencies, and local dev
Inference & Routing SGLang, vLLM, TensorRT-LLM, NVIDIA Dynamo, LMCache, llama.cpp / Ollama, open-weight models (gpt-oss, Qwen3.5, Gemma 3), enterprise APIs Disaggregated prefill/decode, EAGLE-3 speculative decoding, tiered KV cache, and cost-aware routing
Agentic Frameworks & Protocols LangGraph, Pydantic AI, Google ADK, Model Context Protocol (MCP, 2026-07 specification), A2A v1.0 Stateful cyclic supervisor graphs, remote tool execution, and cross-runtime delegation
Guardrails & Memory Llama Guard 4, gpt-oss-safeguard, Qwen3Guard, Graphiti, Mem0 Input/output safety classification and episodic, semantic, and procedural agent memory
Observability & FinOps OpenTelemetry (GenAI semantic conventions), Langfuse, Helicone, Arize Phoenix, Prometheus Distributed tracing, token budgeting, TTFT/ITL latency, and cost telemetry
Infrastructure & Security Terraform / OpenTofu, Terragrunt, OPA Rego, Conftest, Kyverno, Kubernetes (DRA, Inference Gateway), GitHub Actions Declarative IaC, policy-as-code guardrails, GPU scheduling, and zero-trust CI/CD

Research Laboratories

Inference Fabric (inference-fabric)

  • Status: Active Development · Focus: AI Inference & Routing Engineering
  • Tech Stack: Rust (Axum, Tokio) SGLang vLLM NVIDIA Dynamo LMCache Qdrant Helicone OpenTelemetry gpt-oss · Qwen3.5

A high-performance AI infrastructure project exploring disaggregated prefill and decode (DPD) over NIXL, EAGLE-3 speculative decoding, KV cache prefix reuse tiered across GPU, CPU, and NVMe, and cost-aware model selection. It investigates local-first execution of open-weight reasoning models (gpt-oss, Qwen3.5, Gemma 3) paired with real-time token latency (TTFT/ITL) and cost telemetry.

Key Capabilities:

  • Low-latency semantic caching and KV prefix reuse with dynamic similarity thresholds, tiered through LMCache.
  • Disaggregated prefill and decode (DPD) router on NVIDIA Dynamo, hardened with circuit breakers, fallbacks, and token budgeting.
  • Local-first EAGLE-3 speculative decoding for high-frequency reasoning and utility tasks.
  • Sub-millisecond token latency (TTFT/ITL) and consumption tracing via OpenTelemetry GenAI conventions.

Data Fabric (data-fabric)

  • Status: Active Development · Focus: AI Data Platforms & Lakehouses
  • Tech Stack: Apache DataFusion Polars Apache Iceberg v3 DuckLake LanceDB PostgreSQL Qdrant LadybugDB

A local-first analytical data platform exploring vectorized engine execution, open table formats (Apache Iceberg v3 through the REST catalog, with deletion vectors, row lineage, and the variant type; DuckLake as the SQL-catalog alternative), Lance columnar vector storage, and hybrid Graph RAG retrieval. It syncs real-time streaming ingestion with vector representations for AI-native analytics with zero cloud infrastructure dependencies.

Key Capabilities:

  • Open table format integration using the Apache Iceberg v3 REST catalog (Apache Polaris, Lakekeeper) with deletion vectors, row lineage, and snapshot isolation.
  • Hybrid retrieval combining embedded LanceDB vector search and LadybugDB graph traversal.
  • Single-binary embedded analytical query execution via Apache Arrow DataFusion.
  • Local-first operation with cloud-portable deployment paths (BigQuery, Snowflake, Databricks).

Agent Fabric (agent-fabric)

  • Status: Active Development · Focus: Agentic Systems & Remote MCP Architecture
  • Tech Stack: LangGraph Pydantic AI Model Context Protocol (MCP) A2A Redis FastAPI Llama Guard 4 gpt-oss-safeguard

An omnichannel agent runtime research project exploring stateful multi-agent supervisor graphs, remote Model Context Protocol (MCP) servers over Streamable HTTP with OAuth-aligned authorization (2026-07 specification), Agent2Agent (A2A) delegation across runtimes, and enterprise communication workflows within secure identity boundaries.

Key Capabilities:

  • Stateful multi-agent delegation and cyclic workflow choreography with human-in-the-loop checkpoints.
  • Remote tool discovery and context sharing over MCP (Streamable HTTP, OAuth-aligned authorization) and cross-runtime task delegation over A2A.
  • Omnichannel gateway adapters (Slack, Microsoft Teams, WebSockets) with real-time streaming.
  • FastAPI rate limiting, policy-following safety classification (Llama Guard 4, gpt-oss-safeguard), and Redis session state TTL management.

Engineering Fabric (engineering-fabric)

  • Status: Completed · Focus: Software & Analytics Engineering
  • Tech Stack: Python LangGraph Pydantic AI dbt-core GitHub API Docker

An autonomous software remediation system investigating how agentic workflows can diagnose, validate, and repair pipelines for engineering teams. It resolves dbt-based platform failures and infrastructure configurations, generating pull requests under human oversight.

Key Capabilities:

  • Automated failure diagnosis utilizing error logs and parent lineage context.
  • Test-driven code fix generation and containerized dry-run validation.
  • PR generation containing affected lineage reports and Slack approval gates.

Eval Fabric (eval-fabric)

  • Status: Completed · Focus: AI Evaluation & Benchmarking
  • Tech Stack: DeepEval Braintrust Phoenix LangSmith OpenTelemetry Pytest

A systematic evaluation harness designed to benchmark prompts, agents, and complex LLM workflows. It focuses on regression testing, hallucination tracking, and synthetic dataset generation to establish a verifiable baseline of model performance, latency, and cost metrics before deployment.

Key Capabilities:

  • Automated regression testing for agentic decision trees.
  • Prompt benchmarking against curated golden datasets and synthetic test generation.
  • Multi-evaluator LLM-as-a-judge pipelines with consensus scoring and pairwise ranking.

Knowledge Fabric (knowledge-fabric)

  • Status: Planned · Focus: Context Engineering & Graph RAG
  • Tech Stack: LlamaIndex LadybugDB Graphiti Qdrant LanceDB Python Pytest

An entity-relation semantic memory system designed to manage unstructured context through hybrid Graph RAG and lineage-aware traversal over a temporally aware knowledge graph. It extracts relationships, builds local knowledge graphs, and resolves semantic queries to construct structured episodic, semantic, and procedural context for long-term agent memory.

Key Capabilities:

  • Hybrid retrieval combining vector search and graph traversal.
  • Structured entity-relation extraction loops with schema checks and temporal validity of facts.
  • Stateful, lineage-aware memory graph across execution sessions.

Governance Fabric (governance-fabric)

  • Status: Planned · Focus: AI Governance & Policy-as-Code
  • Tech Stack: LangGraph Pydantic AI OPA Rego Conftest Kyverno SQLite

A multi-agent architecture governance prototype built to automate design reviews, policy validation, and structured audits. It ingests architectural records (ADRs) and RFCs, running consensus-seeking agents to evaluate compliance against strict Policy-as-Code rules, including the tool-authorization policies agents run under.

Key Capabilities:

  • Compliance auditing using Open Policy Agent (OPA) Rego policies.
  • Multi-agent consensus-based architectural decision reviews.
  • Failed ADR archival with structured metadata for post-mortem analysis.

Platform Fabric (platform-fabric)

  • Status: Planned · Focus: Runtime Operations & GitOps
  • Tech Stack: Kubernetes Terraform / OpenTofu Terragrunt Crossplane ArgoCD OpenBao / HashiCorp Vault

A declarative platform orchestration layer managing multi-cloud Kubernetes environments — dynamic resource allocation (DRA) for GPUs and the Gateway API Inference Extension for model routing — together with GitOps state synchronization and zero-trust IAM secrets. It automates environment provisioning and prevents configuration drift.

Key Capabilities:

  • Automated provisioning of cloud environments using modular Terraform / OpenTofu, with Crossplane for developer-facing control planes.
  • ArgoCD GitOps reconciliation to prevent cluster configuration drift.
  • Zero-trust runtime credential retrieval mapped to container roles, with GPU scheduling through DRA.

Fabric Ops (fabric-ops)

  • Status: Planned · Focus: Platform Observability & FinOps
  • Tech Stack: OpenTelemetry Prometheus Mimir Loki Tempo Pyroscope Grafana Alloy Grafana Helicone

A centralized SRE observability pipeline collecting logs, distributed traces, continuous profiles, and cost telemetry across all active fabrics. It aggregates token and compute consumption to enforce FinOps policies in real time.

Key Capabilities:

  • Centralized OpenTelemetry pipelines (Grafana Alloy) for metrics, logs, distributed traces, and continuous profiling.
  • Distributed trace tracking across multi-agent supervisor loops.
  • Real-time token consumption cost tracking for FinOps alerting.