I’m Cesar, a Senior AI Engineer at Coinbase focused on autonomous AI agents, enterprise RAG systems, and LangGraph-based production architectures. My work sits at the intersection of large-scale distributed systems and cognitive architectures for "agency"—taking LLMs beyond chat into reliable, observable, and controllable agentic systems that operate at enterprise scale.

In one line: I design and ship production-grade AI agents and knowledge systems that can act on real workflows, not just answer questions.

My background in Philosophy (UC Berkeley) and Psychology (NYU) shapes how I design non-deterministic systems. I think in terms of mental models, boundaries, and agentic intentionality: what an agent knows, what it can’t know, and how it chooses to act under uncertainty.

For autonomous AI agents in production, this translates to:

• Explicit Mental Models & Boundaries: Clearly modeling an agent’s goals, knowledge, tools, and escalation paths.
• Stateful Orchestration with LangGraph: Building inspectable state machines with explicit transitions and guardrails instead of opaque prompt-chains.
• Cognitive Loops & Feedback: Reflection, self-critique, and planning loops that mirror human reasoning to improve reliability over time.
• Observability-First Design: Every agent action is traced, evaluated, and tied back to business outcomes using tools like LangSmith.

If you’re searching for agentic AI architectures, LangGraph production patterns, or enterprise RAG design, this is the work I do every day.

• Context: At Coinbase, onboarding customers was a time intensive process.
• Role: As part of an internal AI Tiger Team, I architected and led the development of an autonomous onboarding agent that combines vision (UI understanding) with web-browsing capabilities to navigate expedite customer onboarding.
• Architecture: Multi-agent LangGraph orchestration, LangSmith-driven observability, tool-augmented browsing, and policy-guarded actions. Integrated with internal services via Kafka, Golang, and Python microservices, with Postgres for state and checkpointing.
• Impact: The agent's findings and results saves hundreds of hours monthly.
• Keywords: autonomous AI agents, enterprise AI agents, AI agent building, LangGraph in production, agentic workflows, observability-first design.

• Context: Teams needed a reliable way to prototype and harden RAG pipelines over heterogeneous, evolving knowledge bases (docs, wikis, tickets, code, internal tools).
• Role: I designed and built a Knowledge Base Engine (KB Engine) and public KB Engine Playground that make it easy to stand up, iterate on, and evaluate production-ready RAG pipelines.
• Architecture: Config-driven ingestion graph that automates Fetch → Parse → Chunk → Embed, combining vector + symbolic retrieval, pluggable rerankers, and LangGraph-based flows for complex multi-hop queries. Backed by Postgres/pgvector, orchestrated via Kubernetes scheduled jobs and chart-driven configs.
• Impact: Enabled rapid iteration on RAG strategies, objective evaluation of retrieval performance, and smoother promotion from “playground” experiments into hardened enterprise RAG services.
• Links:
  • KB Engine Playground (GitHub): github.com/cesarb-ai/kb_engine_playground
  • Repo in this workspace: ./kb_engine_playground
• Keywords: enterprise RAG, knowledge base engine, automated RAG pipelines, pgvector, LangGraph RAG, retrieval evaluation, knowledge management.

I specialize in turning research-grade ideas into production-grade autonomous AI systems.

Area	Badge	Focus
AI Agent Building		Designing and deploying multi-step, tool-using agents with explicit LangGraph state machines.
RAG / Knowledge Systems		Architecting enterprise RAG stacks with robust retrieval, evaluation, and governance.
Multi-Agent Systems		Coordinating specialized agents (planner, researcher, executor, critic) for complex workflows.
Observability (LangSmith)		Tracing, evaluating, and hardening agent behavior with systematic feedback loops.
Distributed Systems (Kafka / Go)		Building reliable, event-driven backends that support real-time, agentic workloads.

Core Stack & Domains: LangGraph, LangChain, LangSmith, Postgres (pgvector), Kafka, Golang, Python, Docker/Kubernetes, Redis, event-driven architectures, and modern observability stacks.

• Coinbase Engineering Blog – Writing on AI agent building, enterprise RAG, and productionizing LangGraph-based systems.
  👉 Building Enterprise AI Agents at Coinbase
• LangChain Interrupt 2026 – Attending as part of Coinbase’s efforts around AI-powered support systems and agentic infrastructure; my EM will present a high-level overview of an AI-powered support system for which I authored the technical design and led implementation alongside my team.
  👉 LangChain Interrupt

These venues reflect my focus on sharing real production lessons—not just demos—with the broader AI engineering and MLOps community.

I focus on the hard parts of AI engineering: production-grade infrastructure, deep observability, security and safety, state persistence, deterministic behavior on top of non-deterministic models, and scalable RAG and knowledge base infrastructure. My advisory and consulting work is oriented around systems where infra, security, and observability are first principles, not bolt-ons.

If you’re exploring:

• Autonomous AI agents for real business workflows (not toy chatbots),
• Enterprise RAG platforms over messy, high-stakes knowledge bases,
• LangGraph production deployments with observability, governance, and safety baked in,
• Or knowledge base engines that continuously ingest, index, and evaluate your internal knowledge,

…I’m interested in advising, consulting, or collaborating on your Agentic AI Infrastructure.

• Website: cesarb.ai
• GitHub: cesarb-ai
• LinkedIn: longlivecesar

If you’re building the next generation of agentic systems, LangGraph-based architectures, or enterprise RAG platforms, I’d love to talk.

Keywords (for search & discovery): autonomous AI agents, AI agent building, LangGraph, LangGraph in production, LangChain, enterprise RAG, knowledge base engine, KB Engine, pgvector, Postgres, Kubernetes, Docker, Kafka, Golang, Python, LangSmith, observability, multi-agent systems, agentic workflows, AI infrastructure, Agentic AI, enterprise AI agents.