Skip to content

Active Labs

Incubating applied research projects, high-performance prototypes, and engineering utilities under active development.

This section serves as my public engineering laboratory for active project incubation and hands-on Research and Development on the frontier of Data and AI. I use these spaces to design, build, and benchmark modern software systems, focusing on low-latency architectures, cost optimization, and secure design principles.

Each project represents an active engineering sandbox used to explore emerging AI infrastructure, data systems, and agent architectures. These projects are under active development and serve as practical vehicles for experimentation, benchmarking, architectural validation, and continuous learning.

Project Availability

Projects in Active Labs are currently developed in private repositories while architectural concepts, implementation patterns, and performance characteristics are being evaluated. Select write-ups, architectural reviews, and open-source blueprints are released as they mature.

Engineering Foundation

My applied research is guided by a unified architectural blueprint to ensure that local experimentation translates directly into production-grade deployments.

Architectural Principles

  • ADR-001 — Open Source First: All systems must remain deployable without mandatory cloud dependencies to enable rapid local experimentation.
  • ADR-002 — Local First: Development, validation, benchmarking, and experimentation occur locally before staging.
  • ADR-003 — Cloud Portable: Architectures are designed to be portable between GCP (Primary) and AWS (Secondary).
  • ADR-004 — Evaluation Before Deployment: Agentic workflows must undergo systematic regression testing and benchmarking before deployment.
  • ADR-005 — Human-in-the-Loop: AI systems propose actions and generate draft assets, but humans retain final approval authority.
  • ADR-006 — Cost-Aware AI: Inference systems actively optimize the trade-offs between cost, latency, reliability, and quality.

Technology Strategy

  • Core Languages: Python 3.13+, Rust
  • Data Layer: PostgreSQL, Apache Iceberg (v3), Parquet, LanceDB, Qdrant, KuzuDB (Graph)
  • Inference Layer: Local LLMs (Ollama, SGLang, vLLM), Enterprise LLM APIs
  • Agentic Layer: LangGraph, Pydantic AI, Model Context Protocol (MCP)
  • Observability: OpenTelemetry, Helicone, Phoenix
  • Infrastructure: Docker Compose, GitHub Actions, Terraform, Kubernetes

Research Laboratories

Inference Fabric (inference-fabric)

  • Status: Active Development | Focus: AI Inference & Routing Engineering
  • Tech Stack: Rust (Axum, Tokio), SGLang, vLLM, Qdrant, Helicone, OpenTelemetry, Local LLMs, Enterprise APIs

A high-performance AI infrastructure project exploring disaggregated LLM inference routing, speculative decoding, semantic caching, and cost-aware model selection. It investigates local-first execution of open-weights reasoning models paired with real-time token latency (TTFT/ITL) and cost telemetry.

Key Capabilities:

  • Low-latency semantic caching with dynamic similarity thresholds.
  • Cost-aware inference router hardened with circuit breakers, fallbacks, and token budgeting.
  • Local-first speculative execution for high-frequency utility tasks.
  • Sub-millisecond token latency (TTFT/ITL) and consumption tracing via OpenTelemetry & Helicone.

Data Fabric (data-fabric)

  • Status: Active Development | Focus: AI Data Platforms & Lakehouses
  • Tech Stack: Apache DataFusion, Polars, Apache Iceberg, LanceDB, PostgreSQL, Qdrant, KuzuDB

A local-first analytical data platform exploring vectorized engine execution, open-table formats (Apache Iceberg v3), 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 Apache Iceberg v3 REST catalog with snapshot isolation.
  • Hybrid retrieval combining embedded LanceDB vector search and KuzuDB 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 & MCP Architecture
  • Tech Stack: LangGraph, Pydantic AI, Model Context Protocol (MCP), Redis, FastAPI, Llama Guard 4

An omnichannel agent runtime research project exploring stateful multi-agent supervisor graphs, native Model Context Protocol (MCP) server integration, streaming event delivery (SSE), and enterprise communication workflows within secure identity boundaries.

Key Capabilities:

  • Stateful multi-agent delegation and cyclic workflow choreography with human-in-the-loop checkpoints.
  • Native tool discovery and execution using the Model Context Protocol (MCP).
  • Omnichannel gateway adapters (Slack, Microsoft Teams, WebSockets) with real-time SSE streaming.
  • FastAPI rate limiting, Llama Guard safety filtering, and Redis session state TTL management.

Engineering Fabric (engineering-fabric)

  • Status: Completed | Focus: Software & Analytics Engineering
  • Tech Stack: Python, LangGraph, Pydantic AI, dbt, 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, KuzuDB, Qdrant, LanceDB, Python, Pytest validation harnesses

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

Key Capabilities:

  • Hybrid retrieval combining vector search and graph traversal.
  • Structured entity-relation extraction loops with schema checks.
  • 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, 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.

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, Terragrunt, ArgoCD, HashiCorp Vault

A declarative platform orchestration layer managing multi-cloud Kubernetes environments, 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.
  • ArgoCD GitOps reconciliation to prevent cluster configuration drift.
  • Zero-trust runtime credential retrieval mapped to container roles.

Fabric Ops (fabric-ops)

  • Status: Planned | Focus: Platform Observability & FinOps
  • Tech Stack: OpenTelemetry, Prometheus, Mimir, Loki, Tempo, Grafana, Helicone

A centralized SRE observability pipeline collecting logs, distributed traces, 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 for metrics, logs, and distributed traces.
  • Distributed trace tracking across multi-agent supervisor loops.
  • Real-time token consumption cost tracking for FinOps alerting.