I build AI systems that ship.
AI engineer building production-grade LLM and agent systems in TypeScript. I designed and shipped a 43-tool MCP server and a multi-tier Claude orchestration layer from zero, backed by 6,000+ tests and end-to-end observability. I build for production, not demos. Open to AI engineering roles where I can bring that to a team.
const result = await mcp.callTool(
'generar-factura', params
);
const client = new Anthropic();
const msg = await client.messages
.create({ model, tools });
About Me
Background
My path to AI engineering wasn't a straight line, and that's where the edge comes from.
I started in graphic design and tattoo work, where precision and intentionality aren't optional. Then I spent two years writing deep technical research on complex systems (protocol architecture, incentive design, market structure) that trained me to read an unfamiliar system fast, find where it breaks, and explain it clearly. When I found LLMs and the Model Context Protocol, I stopped analyzing other people's infrastructure and started building my own.
Mexican, operating globally, fully bilingual: Spanish native, English professional. EST-aligned, async by default.
What I do
I build the unglamorous parts that make AI agents trustworthy in production:
- MCP server design: full primitive set (tools, resources, prompts, elicitations, MCP-UI), SSE + HTTP Streamable transport, multi-tenant architecture.
- Multi-tier agentic orchestration: a lightweight router classifies intent, domain-scoped agents run native tool_use loops with self-correction, and an Expert Registry enforces per-domain tool allowlists with live resource injection.
- Observability & cost control: end-to-end Langfuse tracing on every LLM call, tool invocation, model choice, and token cost, with per-session attribution and failure triage without log digging.
- Human-in-the-loop surfaces: one-click approval flows wired into the agent pipeline for irreversible operations.
- Production discipline: 6,000+ tests, 91%+ coverage, CI/CD, schema validation at every boundary, conventional commits, drift guards. The hygiene that makes solo-built work safe to hand to a team.
Stack & Expertise
AI Systems & LLM Orchestration
Anthropic Claude API (tool_use, streaming, multi-turn), MCP Protocol (full primitive set), multi-agent orchestration, Expert Registry pattern, scoped tool allowlists, Langfuse tracing, HITL approval patterns.
Backend & Infrastructure
TypeScript / Node.js, Python, PostgreSQL (RLS, pgvector), SQLite, Redis, Docker, Railway, CI/CD pipelines, rate limiting, security headers, observability and monitoring. REST API design, Zod schema validation, circuit breakers, multi-tenant architecture.
Frontend & Interfaces
Next.js, React, Tailwind CSS, shadcn/ui, SSE streaming UIs, real-time data visualization (ApexCharts, Recharts). TypeScript throughout.
Automation & Workflows
n8n (self-hosted, multi-client deployments, complex workflow design), webhook orchestration, scheduled pipelines, third-party API integration. Familiar with Make and Zapier; migrated workflows to self-hosted n8n for full data ownership and agent-native integration.
Certifications & Credentials
Selected highlights below.
Model Context Protocol: Advanced Topics
Anthropic • October 7, 2025
Claude Code in Action
September 25, 2025
Building Scalable Agentic Systems
2025
n8n Self-Hosted for Enterprises
November 2025
Projects
SAT-MCP: 43-tool fiscal MCP server
A production MCP server for Mexican tax compliance (CFDI 4.0). Full primitive set plus 8 MCP-UI mini-apps for in-chat document rendering, SSE + HTTP Streamable transport, multi-tenant CSD management, 5 PAC providers behind circuit breakers, and EFOS/EDOS blacklist monitoring. 5,500+ tests, 91%+ coverage, solo-built in strict TypeScript. Private commercial product. Happy to walk through the architecture and code in an interview.
Tech Stack:
DISAI_Conta: 3-tier agent system
An AI-native fiscal platform built on SAT-MCP. A Haiku router classifies ten fiscal domains in ~100ms, ten Sonnet domain agents run native tool_use loops (up to 6 iterations, parallel calls, self-correction), and an Expert Registry injects the right SAT catalog resources into context before the first call, which removes an entire class of hallucinated catalog codes without RAG query overhead. Langfuse traces everything; a HITL dashboard gates irreversible operations; streaming SSE chat built in Next.js 16.
Tech Stack:
Crypto / TradFi Analytics Terminal
A real-time analytics dashboard aggregating on-chain and traditional market feeds over dual WebSockets, with a Node.js backend, Redis caching, and graceful degradation for low-latency uptime. React + TypeScript, Dockerized, deployed on Railway/Vercel.
Tech Stack:
n8n freelancer starter
A one-click Railway template for self-hosted n8n, production-configured, built to replace the $20–30/mo Zapier/Make dependency for small teams.
Tech Stack:
Open-Source Building Blocks
Small, fully-typed primitives I pulled out of building the platform - each solves one production problem, ships with 90%+ test coverage, and is public on GitHub.
$ pnpm add mcp-tool-idempotency
retry ─► claim ─► run ×1
└ replay cached result
mcp-tool-idempotency
Exactly-once execution for MCP tool calls (or any costly async op) so retries never fire side effects twice. A two-layer store: an in-process in-flight map that dedupes concurrent retries with zero round-trips, over a pluggable backend doing an atomic claim + TTL for cross-restart replay. Failed runs are never cached, so retries stay allowed. Zero-infra by default; 90%+ coverage.
Tech Stack:
$ pnpm add llm-cost-router
small → Haiku reasoning → Sonnet
cache read ×0.10 write ×1.25
llm-cost-router
Tiered model routing plus cache-accurate LLM cost tracking in ~200 lines of pure, immutable functions - no SDK, no network. Routes the cheapest model that can do the task and meters spend correctly, including prompt-cache multipliers (a cache read bills at ~0.10x, a cache write at ~1.25x) that naive trackers silently miscount. Ships an Anthropic pricing preset and session budget guards.
Tech Stack:
$ pnpm add agentic-tool-loop
model ⇄ tools (multi-turn)
self-correct · stop on end_turn
agentic-tool-loop
A tiny, fully-typed agentic tool-use loop for the Anthropic Messages API - ~120 lines, no framework. The model calls multiple tools across turns, sees its own tool failures and self-corrects, and stops when it decides it's done, while hard guards keep it from running forever, hanging on a safety refusal, or sending a malformed follow-up. Exercised end-to-end against a scripted mock client - no API key needed to run the tests.
Tech Stack:
efos-risk-graph
Fiscal-risk propagation for the Mexican SAT Art. 69-B blacklist (EFOS/EDOS), derived from the math up. Models invoicing as a directed graph and answers 'how many hops am I from an EFOS?' - risk decays per hop, the score is the single worst chain (a max, with an explaining path an auditor can read), and a white/grey/black DFS flags invoicing carousels. Open-core: the engine is public, the edges stay private.
Tech Stack:
euler-worked-out
Project Euler solutions where the goal is understanding why it's the answer, not just the answer. Each problem is treated like a tiny paper: derive the closed-form insight by hand (inclusion-exclusion, arithmetic series, number theory), then verify it against a straightforward brute force in Python, and note the trade-offs (O(n) vs O(1)). If the hand derivation and the program disagree, one of them is wrong - and finding out which is the point.
Tech Stack:
Systems Analysis
Before building AI systems, I spent years producing deep technical research on complex economic and protocol systems: consensus mechanism design, cryptoeconomic incentive structures, Layer 2 scaling architectures, and on-chain market microstructure. The same pattern recognition and architectural thinking now drives how I design and reason about AI infrastructure.
Writing
I write about what I actually build: the non-obvious problems, the design decisions, and what breaks in production.
Let's work together
Open to AI engineering roles, and the occasional high-leverage build. Email is the fastest way to reach me.