I build AI platforms and production AI systems for environments where reliability, security, observability, evaluation, and governance matter as much as model capability.

My work is hands-on and sits at the intersection of software engineering, distributed AI systems, agentic workflows, LLM infrastructure, security, and architecture.

A recurring principle across my projects is keeping critical authority outside probabilistic components:

Models may reason and propose. Trusted software authorizes, constrains, executes, and produces evidence.

I bring more than 22 years of experience in financial services, including Caixa, BTG Pactual, Banco do Brasil, Itaú Unibanco, and ASA SCFI. This background shapes how I approach AI systems operating around sensitive data, financial workflows, regulation, auditability, and operational risk.

These repositories best represent the architecture and engineering problems I am currently focused on.

I am interested in the shared capabilities that allow multiple AI products and teams to run on a common, governed foundation.

flowchart TB
    Apps["AI Applications / Agents / Workflows"]

    Gateway["Governed LLM Gateway<br/>Execution · Resilience · Provenance"]
    Router["Policy Model Router<br/>Authorization · Logical Model Groups"]
    Providers["LLM Providers"]

    Boundaries["Agent Runtime Boundaries<br/>State Ownership · A2A · Replay"]
    Governance["Governance & Runtime Assurance<br/>Policy · Approval · Evidence"]
    Identity["Identity & Tool Access<br/>OAuth/OIDC · MCP · Least Privilege"]
    Observability["Observability<br/>OpenTelemetry · A2A · MCP"]
    Evaluation["Evaluation & Quality<br/>RAG · Evals · Regression"]

    Apps --> Boundaries
    Boundaries --> Gateway
    Gateway -. policy decision .-> Router
    Gateway --> Providers

    Governance -. constrains .-> Gateway
    Identity -. authority boundary .-> Apps
    Observability -. traces .-> Apps
    Observability -. traces .-> Boundaries
    Observability -. traces .-> Gateway
    Evaluation -. validates .-> Apps

The architecture is intentionally modular. Applications should not need provider credentials, provider-specific retry logic, model-selection rules, or hidden authorization logic scattered throughout their codebases.

The same principle applies to agent frameworks: one runtime should own global execution state; other runtimes should expose bounded capabilities behind explicit contracts rather than competing for the same source of truth.

Explore the broader portfolio architecture →

• Built production AI systems for regulated financial institutions, including conversational and transactional assistants, RAG pipelines, agent workflows, observability, security controls, and governance mechanisms.
• Led enterprise AI adoption for approximately 400 users, including Claude Code for around 250 developers and Claude Enterprise for approximately 150 business users.
• Reduced an investment assistant's average context from approximately 70,000 to 3,000 tokens (~95%) using conditional knowledge retrieval and injection, reducing latency, token consumption, and inference cost.
• Designed semantic routing with intent-specific thresholds, positive and negative examples, ambiguity floors, and margin rules, reaching approximately 94.7% accuracy on its validation dataset.
• Designed engineering controls for enterprise AI adoption including coding-agent guardrails, MCP allowlists, deterministic hooks, architecture rules, auditability, incident procedures, and controlled rollout.
• Translate governance and security requirements into executable mechanisms such as fail-closed authorization, segregation of duties, typed contracts, bounded execution, evidence provenance, and human-controlled high-impact actions.

• Authority is explicit. Model output is not authorization.
• One runtime owns global workflow state. Specialist frameworks may keep local context, but should not compete for the same execution truth.
• Checkpoints and side-effect evidence are different concerns. Durable workflow state does not by itself prove whether a remote effect already happened.
• Fail closed when trust is missing. Missing identity, policy, evidence, or configuration must not silently become permission.
• Use the simplest architecture that solves the problem. Agents are not the default answer to every AI workflow.
• Keep deterministic authority around probabilistic reasoning. Models can classify, plan, retrieve, synthesize, and propose without owning every consequential decision.
• Treat identity, tools, providers, retrieved data, runtime boundaries, and telemetry as trust boundaries.
• Evaluate retrieval and generation independently whenever possible.
• Make evidence inspectable. Model self-report is not runtime proof.
• Design for retries and re-execution. Idempotency, bounded retries, checkpoints, effect ledgers, and explicit failure states matter in distributed agentic systems.
• Document guarantees and non-guarantees. A production-oriented architecture should state what it does not prove.

• Policy Model Router - deterministic, fail-closed authorization and routing across logical model groups.
• MCP Server Auth Template - protected remote MCP server reference using OAuth/OIDC patterns.
• MCP Client Auth Template - matching authenticated MCP client patterns.
• Open Finance BR MCP - Open Finance Brasil/FAPI-BR-oriented MCP reference architecture.

• Controlled Autonomy Lab - experimental comparison of augmented LLMs, chaining, routing, parallelization, evaluator-optimizer, and bounded agents across multiple providers.
• Multi-Agent Credit Desk - auditable multi-agent reference workload for financial workflows.
• Meridian - enterprise knowledge architecture with semantic routing, retrieval-time ACLs, structured queries, DSPy, and grounded answers.

• Alicerce - deterministic execution and evidence-gated engineering loops.
• engineering-loop-schemas - canonical contracts for engineering execution evidence and verdicts.
• Claude Python Engineering Harness - repository-owned rules, hooks, architecture constraints, and quality gates for Claude Code.
• Codex Python Engineering Harness - equivalent engineering harness for Codex-based workflows.

• OpsLens - AWS architecture lab for software-supply-chain intelligence combining deterministic evidence, Bedrock RAG, security, evaluation, IAM, CI/CD, and cost engineering.
• Getnet Multi-Agent Support v2 - spec-driven multi-agent support system originally implemented under a constrained technical challenge.

AI Platforms & Architecture
Enterprise AI platforms · model gateways · distributed AI systems · control plane/runtime separation · model routing · provider abstraction · runtime boundaries · durable execution · platform capabilities · developer enablement

Generative & Agentic AI
LLMs · RAG · LangGraph · Agno · CrewAI · durable state machines · multi-agent systems · semantic routing · structured outputs · tool calling · MCP · A2A · DSPy

AI Security & Governance
OAuth 2.1 · OIDC · least privilege · fail-closed authorization · tool boundaries · human-in-the-loop · runtime policy · evidence provenance · auditability · prompt-injection authority boundaries

Evaluation, LLMOps & Observability
Golden datasets · retrieval evaluation · answer quality · citation support · regression evaluation · OpenTelemetry · W3C Trace Context · OTLP · Datadog · Langfuse · Grafana · Tempo · distributed tracing · latency/token/cost observability

Cloud & Platform Engineering
AWS · Azure · Amazon Bedrock · Azure OpenAI · Terraform · Docker · Kubernetes · CI/CD · GitHub Actions OIDC · IAM · event-driven systems · observability · cost controls

My professional background spans corporate banking, credit, treasury, financial operations, software engineering, production AI, enterprise AI adoption, and AI governance.

I have worked with requirements and engineering concerns related to environments governed by frameworks and institutions such as BACEN, CMN, CVM, ANBIMA, LGPD, NIST AI RMF, ISO/IEC 42001, OWASP, MITRE ATLAS, CIS Controls, and NIST security guidance.

This experience strongly influences how I design AI systems: regulation and governance are not documentation layers added after implementation; they become architecture, controls, runtime behavior, and evidence.