Chuck Conway

• Built DCAF, a Python framework on Agno and FastAPI that abstracts the AI infrastructure layer (provider auth, security scoping, conversation state, streaming, tool calling, and HITL approval) so engineers only write domain logic.
• Shipped to production: 6–8 agents from 3–4 engineers across the company, including the Architecture Diagram Agent, a Kubernetes operations agent, a database explorer, and an internal private GPT. Deployed to ~40 customer environments.
• Unified provider abstraction across AWS Bedrock and GCP Vertex AI with a normalized scope model that handles per-provider security, credentials, and auth, including cross-cloud credential brokering for cluster migration scenarios.
• Layered application-level security on top of cloud IAM: DuploCloud's tenant boundary model is enforced at the agent layer, complementing AWS/GCP token permissions.
• Designed the HITL approval model: started with approve-everything, redesigned to read-safe / write-approve after the friction killed usability. Reads auto-approve within scope; mutations require explicit confirmation.
• Built prompt caching as a framework feature: engineers declare static and dynamic prompt segments, and DCAF orders them to leverage Bedrock's native caching.
• Hot-swappable models in flight, per agent and per request.
• Real-time streaming via SSE, then WebSockets when bidirectional communication became necessary (user interrupts, queued messages during processing).
• First-class support for tool calling (custom decorator, native Agno tools, MCP tools), MCP server hosting, and A2A endpoints for inter-agent communication.
• Self-contained: FastAPI built in, runs on port 8000 out of the box. New agent in one or two lines.
• Pre-DCAF: built direct Bedrock integrations using Boto3, with hand-rolled streaming, conversation management, and tool calling. That experience drove DCAF's abstractions.

• Built an infrastructure discovery agent that scans customer cloud environments via Lyft's Cartography, persists the resource graph in Neo4j, and exposes it for natural-language query.
• Real customer adoption: deployed at a healthcare customer where the engineering director who'd been fielding constant “where is X deployed” interrupts began routing those questions to the agent. Cut interrupt load to near-zero over a multi-month engagement.
• Built a custom Cartography plugin for ~12 DuploCloud-specific resource types, injected into Cartography's official Docker image at build time. Avoided forking, kept the plugin repo lightweight, and took upstream updates with zero merge conflict cost.
• Solved the LLM context window problem before it hit production. With 10,000+ nodes across hundreds of types, the schema couldn't fit in the LLM's context for accurate Cypher generation. Built a schema routing layer in ChromaDB: node names stored alongside synonyms (“pod” / “Kubernetes pod” / “k8s pod” / “Duplo pod”), domain classification (AWS / Kubernetes / DuploCloud), and semantic search loading only relevant schema slices per query. Cypher accuracy went from frequent hallucination to reliably executable.
• Used Claude Sonnet via Bedrock to enrich raw Cartography data with semantic labels, analyzing ambiguous field names like type_status and generating human-readable annotations (“the state of the pod: up, down, pending”). Made the graph queryable by humans and LLMs.
• Designed application-layer security scoping for Cypher queries: mapped AWS resources to DuploCloud tenant boundaries and constrained generated Cypher to stay within the user's tenant scope. Worked around Cypher constructs that defeated deterministic security checks.

• Built a Node.js CLI to automate DuploCloud's customer upgrade process across 200+ environments, replacing manual click-ops with scriptable execution of Scribe (an internal JSON/YAML automation language).

• Python
• FastAPI
• Agno
• AWS Bedrock
• GCP Vertex AI
• Claude Sonnet
• Boto3
• Cartography
• Neo4j
• Cypher
• ChromaDB
• MCP
• A2A
• Docker
• Kubernetes
• SSE
• WebSockets
• Node.js
• Claude Code
• Cursor
• Windsurf

A personal AI operating system that began as a chat-UI experiment (“Butler” on Heroku) and evolved over a year of daily use into a system spanning conversational AI, ambient intelligence, and integrations across calendar, email, finance, tasks, reading, and wellness.

• 8 specialized AI tool agents: orchestrated through Agno with runtime-switchable LLM providers (Claude, Gemini, OpenAI). Cover calendar, reminders, tasks, memory, knowledge, financial, reading, and weather.
• Ambient intelligence architecture: event-driven system where domain publishers emit to a Redis Streams bus, a pattern engine correlates them, and 5 ambient agents (finance, calendar, email, wellness, memory) proactively surface insights without prompting. Includes consumer groups, priority streams, dead letter queues, and event deduplication.
• Real operational load: every Gmail message flows through the event bus and is summarized hourly; whitelisted senders and LLM-flagged urgent messages surface in real time. Daily briefings, scheduled report cadences, and ambient triggers fire on cron throughout the day.
• Hybrid retrieval over personal knowledge: pgvector embeddings with keyword + semantic + RRF fusion search across documents, notes, and emails.
• Self-hosted production infrastructure: home-lab Kubernetes (k3s) with Gitea-based CI, PostgreSQL backups to Cloudflare R2 (2x daily, 14-day retention), GitHub Actions pipelines, GitHub Container Registry, multi-domain deployment with PWA manifests. Runs at ~$50/month, mostly LLM API spend.
• Architecture: layered architecture enforced by import-linter, repository pattern across 60+ repositories, async unit-of-work transaction scoping, capability registry with database-backed feature toggles and dynamic cron scheduling, Alembic with expand/contract migrations for zero-downtime deployments, swappable LLM and task providers.
• Scale: 45+ API modules, 60+ repositories, 50+ use-case orchestrators, 24+ database models, 20 frontend feature slices, 10+ external integrations (Gmail, Google Calendar, Microsoft To Do, Todoist, Telegram, Readwise, Simplifi, Dropbox, AccuWeather, GitHub).
• Trust Ladder: designed a graduated autonomy model where ambient agents earn autonomy through demonstrated reliability rather than being granted it upfront. Most agents currently operate at observe-and-surface; the model is in place but most have not yet earned promotion to autonomous action.

• Python 3.14
• FastAPI
• Pydantic v2
• PostgreSQL 17
• pgvector
• Redis Streams
• SQLAlchemy 2.0 async
• SAQ
• Agno
• Anthropic Claude
• Google Gemini
• OpenAI
• React 19
• TypeScript
• Tailwind CSS v4
• Docker
• Kubernetes (k3s)
• GitHub Actions
• Alembic
• Cloudflare R2
• Jest
• Playwright

A platform that turns raw one-take video recordings into publish-ready content: automatically removing mistakes, adding overlays, generating metadata, and producing companion blog articles. Three to four videos shipped through the pipeline.

• 18-step state machine pipeline: with automatic dependency resolution and a recipe system for targeted workflows (subtitles only, music only, overlays only). Reduces 2–4 hours of manual editing to ~15 minutes per video.
• Evolved from CLI to platform: dashboard + project + worker queue architecture. Workers poll for pending jobs, process video, upload artifacts to R2, and report status. Designed to scale horizontally.
• Multi-LLM orchestration by strength: Gemini for large-context transcript analysis, Claude for content generation and overlay design, GPT for evaluation and fallback.
• Knowledge base over personal Obsidian vault: hybrid ChromaDB + BM25 search with attribution detection that classifies notes as original ideas, referenced material, or personal content.
• Frame-perfect video editing: via MLT framework, with zero A/V sync drift across automated cut, retake removal, and overlay composition.

• Python
• Claude (Sonnet/Opus)
• Gemini
• OpenAI GPT
• ElevenLabs
• MLT Framework
• FFmpeg
• ChromaDB
• BM25
• html2image
• Auphonic
• Cleanvoice

A GenAI chatbot built to assist Dell salespeople with quote generation. Dell creates ~9 million quotes per year; 60% are under $5K and average 20 minutes each. Goal: cut quote time and improve accuracy by automating research-and-configuration work.

• Built the entire solution end-to-end: Python/Flask backend, React frontend, prompt design, guardrails, integration with Dell Sales Application (DSA) and the Premier B2B portal.
• Migrated from Dell's internal LLMs (4K context, insufficient reasoning) to GPT-4 via Azure OpenAI, doubling context and significantly improving response quality.
• Built a RAG pipeline feeding product configuration data into context, returning correctly matched products against natural-language criteria (e.g., “find all laptops with i5, 16GB RAM, under $1500 for customer Post Holdings”).
• Implemented prompt engineering and guardrails to scope the chatbot to Dell sales scenarios and prevent misuse.
• Demos validated multiple use cases (spec lookup, frequency-of-purchase queries, in-conversation purchase triggering). Greenlit for full development in the next fiscal year.
• Recognized at the business unit level; received a performance bonus.

• Python 3.11
• Flask
• React 18
• GPT-4 via Azure OpenAI
• RAG
• Pivotal Kubernetes Service
• GitLab CI

A POC using agentic AI (ReAct framework) to assist with multi-jurisdiction tax calculations. Dell sells across many tax jurisdictions with different rules; most validation was manual. Goal: determine whether agentic AI could reason over jurisdiction rules with the right tools.

• Built the full POC stack: React frontend, Python/Flask backend, integration with Dell's internal open-source LLMs (LLAMA 3.2, Mistral, Mixtral).
• Designed an evaluation interface that let business users compare LLMs side-by-side and inspect the agent's ReAct reasoning trace, effectively an early LLM observability surface for non-technical stakeholders.
• Implemented runtime model selection so business users could switch LLMs and compare outputs against the same prompts.
• Roadmap included expanding into RAG over tax documents and broader agentic workflows.

• Python 3.13
• TypeScript 5.0
• React 19
• Flask 3.1
• LLAMA 3.2 8b
• Mistral 7B
• ReAct
• RAG
• Pivotal Kubernetes Service
• GitLab CI

An ML-powered pricing tool that replaced daily Excel-based pricing calculations. SPOT had become a critical-but-fragile production system: the data science team had built it organically without separating ML logic from infrastructure code, and it kept failing in ways that disrupted Dell's global pricing operations.

• Led a team of 3 (Texas, India) to stabilize the system and decouple data science code from infrastructure code, allowing the DS team to iterate on models without breaking production.
• Migrated database from Postgres to SQL Server (Dell did not support Postgres in production), eliminating an unsupported dependency.
• Refactored monolithic codebase using factory and strategy patterns to improve maintainability and testability.
• Established automated deployment pipeline using GitLab CI, HashiCorp Vault, and Docker.

• Python 3.10
• C# 11
• SQL Server 2019
• MLflow 2.0
• ELK
• .NET Core 6
• Pivotal Kubernetes Service
• GitLab CI
• HashiCorp Vault

An internal Q&A platform for Dell's 20,000+ developer community, built as the in-house alternative to a $500K/year StackOverflow Enterprise license.

• Adapted an open-source Python/Django Q&A platform, modernized the UI with React, and integrated ChatGPT for AI-assisted answers: one of Dell's earlier production GenAI integrations.
• Self-taught Python and Django to deliver the project; previously a .NET engineer.
• Authored a weekly division-wide technical newsletter for 10 weeks featuring platform highlights and computer science historical spotlights.
• Established CI/CD deployment to Dell's internal cloud infrastructure via GitLab CI.

• Python 3.9
• Django 4.0
• React 18
• ChatGPT
• SQL Server
• Docker
• Pivotal Kubernetes Service
• GitLab CI

ML-powered automated price optimization platform serving 10 countries on Dell.com. Contributed full-stack to a pre-existing Angular/.NET application: built REST endpoints for global price adjustments, added Angular UI features, and authored Entity Framework queries for performance.

• C# 12
• .NET Core 8
• Angular 16
• SQL Server 2019
• Entity Framework Core 8

Replaced a manual monthly billing process (3 employees, multiple weeks per cycle, 150 customers) with an automated console application that reduced the cycle to a single day.

• Built the integration end-to-end: JWT authentication against the DocuSign API, automated daily import, reconciliation logic, and persistence to EY's billing database.
• Enabled downstream Power BI reporting for finance and account management teams.

• C# 8
• .NET Core 3.1
• Entity Framework Core 3.1
• SQL Server 2016
• DocuSign API
• JWT

EY's existing model required individual firewall rules per application, a pattern that didn't scale and weakened the firewall posture. Led exploration and POC of Azure Application Proxy as an enterprise-wide alternative, eliminating per-application firewall configuration.

• C# 8
• .NET Core 3.1
• Azure Application Proxy
• Windows Server

Goldie is EY's internal chatbot in Microsoft Teams. Led integration of a learning recommendation engine that suggested personalized training based on employee history and peer patterns.

• Architected secure cross-network integration between the Azure-hosted chatbot and the on-premises learning recommendation database.
• Designed network topology with the security team: IP-locked firewall rules, Apache HTTP Server reverse proxy across two firewalls and a DMZ, dual-domain architecture (.net internal, .com external) with corresponding SSL certs.
• Led the security review process for the complete solution.

• C# 7
• .NET Core 3.1
• SQL Server 2016
• Microsoft Azure
• SAP SuccessFactors
• Microsoft Bot Framework
• Apache HTTP Server

Initial assignment on Goldie: built a SAP SuccessFactors integration enabling employees to update their name through conversational chat. Implemented Basic Auth and OAuth flows against the SuccessFactors API for picklist retrieval and data persistence.

• C# 7
• .NET Core 3.1
• SQL Server 2016
• Microsoft Azure
• SAP SuccessFactors
• Microsoft Bot Framework

Led the migration of application secrets from configuration files (checked into source control) into Azure Key Vault. Required refactoring synchronous configuration access into async patterns across affected applications.