Gabriel Santana

About

Gabriel Santana

AI Solutions Architect

[email protected]

I design and build cloud systems, lately with a focus on AI agents: distributed agent platforms, enterprise RAG, and the infrastructure that keeps them running across clouds.

This site is where I write about it: hands-on posts on Azure and architecture, and the Principles I rely on when making design decisions.

Connect on LinkedIn GitHub

CertLabs

Microsoft Azure, from administration to solution architecture.

Azure Solutions Architect Expert

Microsoft Certified

Issued: Dec 2024
Valid until: Dec 2027
Credential ID: A43BBC264A6C62C7

Verify on Microsoft Learn

Azure Developer Associate

Microsoft Certified

Issued: Feb 2025
Valid until: Feb 2027
Credential ID: E5F31124BB3ADBF9

Verify on Microsoft Learn

Azure Administrator Associate

Microsoft Certified

Issued: Nov 2024
Valid until: Nov 2027
Credential ID: 49BF17BCE4622EAB

Verify on Microsoft Learn

Projects

Things I've built

19 projects from my GitHub, from a 2020 indoor map for blind visitors to this year's agent platforms. The big ones first, then the lab.

2022 · 202617 stars

Corollary

An agent runtime that keeps every conclusion tied to the evidence behind it.

Agents usually keep their state as a message log, so a wrong fact at step 3 is read at step 40 with the same trust as a verified tool result. Corollary stores beliefs instead: every claim records what it follows from, and a truth maintenance system retracts each conclusion that depended on a corrected input and re-derives only those. The model just proposes claims; the runtime validates them, runs the tools and builds every context from the beliefs still in force.

Correct one input and only its dependents change: 12 of 20 conclusions in the demo, with zero model calls
Answers ship with a proof a deterministic verifier checks: arithmetic, citations and dates

Python
mypy strict
Claude
OpenAI-compatible
Ollama
MkDocs

Corollary's belief graph: Q2 revenue is corrected, the conclusions that depended on it go OUT and are re-derived, and an independent risk belief stays untouched.

ReachUp's sign-in screen.

ReachUp's indoor map with the visitor's position among the stores.

The side menu with the map, announcements, narrator and feedback.

2020 · 20247 stars

ReachUp!

Google Maps for the inside of a mall, built for people who can't see it.

An indoor location app for blind and visually impaired visitors. Bluetooth beacons around the mall tell the phone where it is, and the app guides the visitor by voice to stores, bathrooms and restaurants. It helps anyone in a hurry too, and mall managers get visit reports and a channel for announcements.

Distance from each beacon's RSSI and TxPower, zones from major and minor ids
A narrator mode and voice search across the whole app

Dart
Flutter
MobX
ASP.NET Core
MySQL
BLE beacons
TypeScript

The beacon layout mapped over a floor plan of the mall.

github.com/gabe-santana/agentic-mesh

AgenticMesh demo: a PDF is ingested, the chat answers with citations and the pipeline trace opens.

The chat with a Markdown answer and the pipeline trace panel.

Document management: uploads, ingestion status and deletion.

2026

AgenticMesh

A distributed platform for AI agents and enterprise RAG.

Upload your documents, chat with an agent that answers from them and cites its sources, and open the trace behind every answer: how long retrieval and generation took, which chunks came back with what score, and the exact system prompt the model saw.

Token-by-token streaming over SSE, rendered as Markdown
Async ingestion: Celery workers chunk, embed and index into Qdrant
Six services, one docker compose up

Python
FastAPI
Celery
Qdrant
PostgreSQL
Redis
Next.js
Azure AI Foundry
Docker

View code Read the story

github.com/gabe-santana/laya-classifier

The laya-classifier dashboard screening a sample inbox.

Emails passing through a scanner gate into deliver, warn and quarantine lanes.

2026

laya-classifier

An email security screener where the model reads and the code checks.

Laya, an open-weights decision model, answers five typed questions about each email in one forward pass, in English and Portuguese. Plain code checks what a model shouldn't guess, like DMARC, lookalike domains and disguised links, and a short policy turns both into deliver, warn or quarantine.

9 of 10 attacks caught, no legitimate email quarantined
About 60 ms per email on a laptop GPU

Python
Laya
PyTorch
FastAPI
ModernBERT

View code Read the story

Sightline cover: video frames becoming timestamped findings.

Sightline on AWS: App Runner, RDS and two Lambda functions in private subnets, calling Bedrock, EventBridge, Transcribe and S3.

2026

Sightline

Autonomous video and audio intelligence for AI agents.

Turns hours of recorded video into auditable answers. Every finding comes back as schema-validated JSON with a video ID, a timestamp and a confidence score, and the model never gets to invent either of the first two.

Ingestion in three EventBridge hops, each with retries and a dead-letter queue
Private subnets, no NAT gateway: every AWS service through a VPC endpoint

Terraform
AWS
Bedrock
Transcribe
EventBridge
Lambda
App Runner
RDS

View code Read the story

Oracle Cloud VCN and Google Cloud VPC connected by an IPsec tunnel between the DRG and the HA VPN.

2026

Hybrid MCP Agent Orchestrator

Google Cloud's AI reasoning over Oracle Cloud's data, bridged by MCP.

A reference architecture for data sovereignty without giving up innovation: Gemini agents on Vertex AI run tools directly against an Oracle Autonomous Database through Model Context Protocol servers on OKE, over a site-to-site HA VPN, without copying the data out.

IPsec IKEv2 with AES-256-GCM, BGP routing, zero-overlap CIDRs
MTU clamped to 1460 bytes so MCP's JSON-RPC payloads never fragment in the tunnel

Terraform
Vertex AI
Gemini
MCP
Cloud Run
OKE
Oracle ATP
Kafka
BGP

github.com/gabe-santana/gsantana-dev

The gsantana.dev home page.

2026

gsantana.dev

This site.

A statically exported Next.js site on Cloudflare, in two languages, where every page is built ahead of time. The few things that need a server, like the newsletter, GitHub sign-in and synced reading progress, are small Pages Functions on D1.

Serverless full-text search that downloads only the chunks a query needs
Diagrams drawn on canvas from one spec for both languages and screen sizes

Next.js
TypeScript
Cloudflare Pages
D1
R2
Pagefind
Tailwind

20212 stars

Track me

Vehicle tracking, from an Arduino in the car to a live map.

My final project in electronics and automation: an embedded Arduino tracker rides in the vehicle and posts its position to an ASP.NET Core API, MongoDB change streams push every new point, and a Flutter app follows the vehicle on the map.

The API deploys to Azure App Service from GitHub Actions

C#
ASP.NET Core
MongoDB
Flutter
Arduino
Azure App Service

From the lab

Smaller projects: compilers, engines, templates and experiments, each one built to learn something.

examples/main.gabRUST

sumTwo = (n1: int, n2: int): int => n1 + n2;
 
main = (argc: int, argv: Array<string>): int => {
    sum: int = sumTwo(1, 1);
    return 0;
}

20214 stars

Gabe language

A compiler written from scratch, for a language of my own.

Gabe is a small, strongly typed functional language with C-like syntax, compiled for Linux on x86. The lexer and tokens are hand-written in C, to learn every stage from lexical analysis to code generation.

C
x86
Make

The py-chess board in its starting position.

2022

py-chess

A chess engine in Python, starting from the board.

The game state, move handling and a pygame board with its piece sprites, with notes toward alpha-beta search and an evaluation function.

Python
pygame

Block diagram of the 8-bit computer's registers, ALU and control unit on a shared bus.

2021

Bart, an 8-bit computer

A computer from logic gates up.

The architecture of an 8-bit computer in the spirit of Malvino's Digital Computer Electronics: program counter, memory address register, 16-byte RAM, instruction register, accumulator, ALU and output register on one bus.

Digital electronics
Computer architecture

theory/superposition.qsC#

operation MeasureSuperposition() : Result {
    use q = Qubit();    // starts in |0>
    H(q);               // |0> and |1> at once
    return MResetZ(q);  // measure, then reset
}

20224 stars

quantum

First steps in quantum programming.

Small Q# programs on the .NET quantum SDK: putting a qubit in superposition, measuring it, and quantum arithmetic operations.

Q#
.NET

20221 stars

stupid-micro-service-arch

Microservices, the smallest version that still counts.

An Ocelot API gateway that authenticates bearer tokens and routes each public path to an Azure Function, with user and post services on MongoDB.

C#
Ocelot
Azure Functions
MongoDB
Docker

srcPlain Text

Application/   services, DTOs, mappers
Domain/        entities
Domain.Core/   repository and service interfaces
Domain.Services/
Infra/         Entity Framework, repositories
Services/API/  controllers, Dockerfile

2021

rest-api-template

A REST API template in DDD layers.

A starting point for .NET 5 APIs: application services with DTOs and mappers, a domain core with repository interfaces, infrastructure on Entity Framework, all in Docker.

C#
.NET 5
EF Core
Docker
DDD

Repositories/BaseRepository.csC#

public class BaseRepository<T> : IBaseRepository<T> where T : class
{
    public async Task<T> Get(int id) =>
        await _context.Set<T>().FindAsync(id);
 
    public async Task<IEnumerable<T>> GetAll() =>
        await _context.Set<T>().ToListAsync();
}

2021

ecomm-api

A generic Web API for e-commerce.

Products and categories behind a generic repository and a unit of work, so each new entity gets its CRUD for free.

C#
ASP.NET Core
EF Core

lib/webapi_web/router.exELIXIR

pipeline :api do
  plug :accepts, ["json"]
end
 
scope "/api", WebapiWeb do
  pipe_through :api
end

2021

web-api-elixir

A JSON API on Phoenix.

A Phoenix API scaffold with Ecto, a JSON pipeline and LiveDashboard telemetry in development.

Elixir
Phoenix
Ecto

pattern_matching/pin_operator.exsELIXIR

x = 1
^x = 2              # ** (MatchError)
[^x, 2, 3] = [1, 2, 3]
{y, ^x} = {2, 1}
[head | _] = [1, 2, 3]

2021

elixir-guide

Notes on Elixir, one concept per file.

Pattern matching, the match operator and the pin operator, written as runnable scripts with the output next to each line.

Elixir

geografical-algorithms/dijkstra.pasPASCAL

for I := 1 to N do
  if (D[C, I] <> 0) and (not ExpA[I]) then
  begin
    NewDA := DA[C] + D[C, I];
    if NewDA < DA[I] then
    begin
      DA[I] := NewDA;
      Ant[I] := C
    end
  end;

2021

Wake up dude, it's time to code in Pascal

Classic algorithms, in a classic language.

Dijkstra's shortest path over an adjacency matrix, bubble sort and quicksort, in Pascal.

Pascal

2021

iso-game

An isometric game in Godot.

The first commits of an isometric game in the Godot engine.

Godot
GDScript