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, Rust
  • Data Layer: PostgreSQL, Apache Iceberg, Parquet, Qdrant, KuzuDB (Graph)
  • Inference Layer: Local LLMs (Ollama, SGLang), Enterprise LLM APIs
  • Agentic Layer: LangGraph, Pydantic AI, Model Context Protocol (MCP)
  • Observability: OpenTelemetry, Helicone
  • Infrastructure: Docker Compose, GitHub Actions, Terraform

Research Laboratories

Inference Fabric (inference-fabric)

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

An experimental AI infrastructure project exploring intelligent inference routing, semantic caching, and cost-aware model selection for modern LLM workloads. It investigates local-first routing for simpler utility tasks utilizing local open-weights models and integrates secure telemetry to observe token consumption.

Key Capabilities:

  • Semantic caching thresholds for low-latency repeating workloads.
  • Cost-aware model routing hardened with circuit breakers and retry logic.
  • Local-first inference execution for utility tasks.
  • High-performance token and latency monitoring via OpenTelemetry.

Data Fabric (data-fabric)

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

A local-first analytical data platform exploring vectorized analytics, open-table formats, graph-aware retrieval (Graph RAG), and AI-native data architectures. It investigates rapid streaming ingestion and vector representation synchronization to enable high-performance data analytics with zero cloud infrastructure dependencies.

Key Capabilities:

  • Open table format integration using Apache Iceberg with snapshot isolation.
  • Embedded vector search and hybrid Graph RAG retrieval.
  • Single-binary embedded analytical queries via DataFusion.
  • Local-first operation with cloud-portable deployment paths.

Agent Fabric (agent-fabric)

  • Status: Active Development | Focus: Agentic Systems
  • Tech Stack: LangGraph, Pydantic AI, MCP, Redis, FastAPI, Llama Guard 4

An omnichannel agent runtime research project exploring canonical event models, stateful orchestration, Model Context Protocol (MCP) integration, and enterprise communication workflows. It prototypes adaptive channel gateways and stateful memory systems within secure boundaries.

Key Capabilities:

  • Stateful multi-agent delegation and cyclic workflow graphs.
  • Omnichannel gateway adapters (Slack, Microsoft Teams).
  • Secure tool execution using the Model Context Protocol (MCP).
  • FastAPI rate limiting 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
  • Tech Stack: DeepEval, LangSmith, Phoenix, OpenTelemetry, Pytest

A systematic evaluation harness designed to benchmark prompts, agents, and complex LLM workflows. It focuses on regression testing and hallucination tracking 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.
  • Multi-evaluator LLM-as-a-judge pipelines with consensus scoring.

Knowledge Fabric (knowledge-fabric)

  • Status: Planned | Focus: Context Engineering
  • Tech Stack: LlamaIndex, KuzuDB, Qdrant, 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.