bk@bkunz.dev ~ $ whoami

~/bkunz.devzsh

$

$

$

$

Competências principais

  • Arquitetura de sistemas de IA

    Orquestração de agentes com tool use sobre adapters de domínio, roteamento de intenção tipado, grounding em queries nativas, recuperação híbrida (BM25 + embeddings), roteamento por propósito com fallback de provedor, prompt caching, medição de tokens e custo por tentativa.

  • Avaliação e guardrails

    Evals pareadas baseline × candidato com seed, teste de McNemar e intervalos de Wilson a 95%, checks determinísticos, LLM-as-judge com rubrica, erros de infraestrutura isolados da taxa de aprovação; canário de vazamento de prompt e shingle guard na saída.

  • Sistemas distribuídos

    Plataformas multi-tenant orientadas a eventos com Outbox e entrega at-least-once, chaves de idempotência, optimistic locking, rate limiting, retries com jitter e controle de concorrência; p99 < 50 ms com mais de 40k conexões; traces, métricas e logs correlacionados.

  • Segurança

    Anti-cheat e anti-abuso em larga escala (inspeção de pacotes, detecção estatística de anomalias), engenharia reversa e análise dinâmica de baixo nível (decompiladores, firmware, DMA), sandboxing, pentest de web e APIs, análise de bypass de guardrails de LLM.

  • Liderança técnica e DevX

    Direção de arquitetura com ADRs, padrões de engenharia e bibliotecas internas, context engineering para agentes de código (skills, subagentes, hooks), orquestração de workers em paralelo, CI/CD integrado com evals.

O que eu construo

Quase tudo o que eu construo são engines: núcleos pequenos e independentes, cada um dono de um problema difícil e capaz de rodar sem os outros. O primeiro é a execução durável. Um workflow é um grafo percorrido por um interpretador determinístico, então reexecutar o mesmo histórico sempre produz as mesmas decisões. Mudanças de estado e mensagens de saída são confirmadas numa única transação por meio de um inbox e um outbox, e toda escrita é idempotente. A consequência é a propriedade que importa: os efeitos acontecem exatamente uma vez, mesmo quando o processo morre no meio de um passo e volta a subir.

Os runtimes de agentes se apoiam na mesma ideia. Uma conversa pode ser conduzida de várias superfícies ao mesmo tempo, então, em vez de guardar estado por cliente, eu guardo a conversa como um log de eventos e derivo cada visão dele como uma projeção. Tudo o que um agente quer fazer e que precisa de uma pessoa passa por uma máquina de estados de aprovação, o gasto é limitado por orçamentos e cada passo entra num ledger de auditoria verificável offline, sem confiar no serviço que o escreveu.

Um agente é tão seguro quanto as ferramentas que ele alcança, por isso o acesso a ferramentas passa por um gateway: um único endpoint MCP na frente de servidores de ferramentas MCP, REST e gRPC. As permissões são concedidas por agente e por função, chamadas arriscadas esperam aprovação humana e as credenciais usam criptografia de envelope. As definições de ferramentas são fixadas por hash, o que fecha um buraco mais silencioso: um servidor não consegue mudar o que uma ferramenta faz, nem o que a descrição dela diz ao modelo, depois que o agente foi autorizado a usá-la.

Às vezes a ferramenta é um computador inteiro. Para isso, os agentes recebem desktops Linux persistentes, com volumes de home e backups, de modo que o trabalho sobrevive entre sessões como sobreviveria para uma pessoa. O acesso é dado por concessões assinadas, não por senhas compartilhadas. Dentro do convidado, um gateway transmite a tela e distribui leases de controle, então percepção e entrada pertencem a um único detentor por vez, e um agente e uma pessoa nunca disputam o mesmo mouse.

Parte do trabalho precisa rodar onde os dados estão, no hardware do cliente. Lá ele é um único binário estático que só faz conexões de saída, se registra com uma chave de dispositivo e executa as tarefas que pegou em lease, então nada naquela rede precisa aceitar conexão de entrada. O que impede todas essas engines de virarem um monólito é um único protocolo de plugins: os adaptadores rodam fora do processo, sobre gRPC, e precisam passar numa suíte de conformidade, então um provedor se encaixa do mesmo jeito em cada engine e pode ser trocado sem mexer em nenhum núcleo.

Como se sustenta

As engines só continuam independentes se seguem as mesmas regras, então é nas regras que vai a maior parte do esforço de design. Cada núcleo é escrito em Go ou TypeScript como portas e adaptadores, e qual adaptador ocupa cada porta é escolhido por configuração, não por código. Cada operação é definida uma vez e exposta por HTTP, gRPC, MCP e uma CLI. Uma pessoa, um serviço e um agente chegam ao mesmo comportamento pela porta que lhes serve, e nenhum deles tem um atalho privado.

Como essas portas são públicas, os contratos por trás delas são versionados e verificados: operações e eventos carregam JSON Schemas, e uma mudança que quebra um consumidor falha antes de ser publicada. O acesso é fechado por padrão e aberto de propósito. A multitenancy é garantida no Postgres com row-level security, então o isolamento vale onde os dados moram; uma consulta que esquece um filtro no código da aplicação continua sem conseguir ler as linhas de outro tenant.

Numa fronteira, a falha é o caso normal, então toda fronteira que altera algo é feita para ser repetida. As mensagens saem por um outbox com entrega at-least-once, e quem recebe torna isso seguro com chaves de idempotência. Escritores concorrentes são reconciliados com optimistic locking, uma checagem de versão dentro do próprio update, em vez de locks mantidos durante uma requisição. Os retries esperam com jitter para não chegarem em ondas, e rate limits e controle de concorrência impedem que um chamador deixe os outros sem recurso.

Os testes seguem a mesma lógica: se o comportamento depende de tempo, de dados e de falhas, o teste precisa controlar os três. As execuções rodam em mundos controlados, com relógio fixo, banco de dados bifurcado e falhas injetadas, então uma condição de corrida ou um timeout é reproduzido sob demanda, em vez de esperado na sorte. O uso é medido num ledger append-only com orçamentos, os artefatos são versionados e traces, métricas e logs são correlacionados pelo OpenTelemetry. Medir duas vezes, otimizar uma.

IA, medida

Eu trato funcionalidades com LLM como sistemas com entradas, custos e modos de falha, não como prompts. Um agente orquestra o uso de ferramentas sobre os mesmos adaptadores de domínio que o resto da plataforma usa, então ele age pelas operações que uma pessoa usaria, com as mesmas permissões. As requisições são roteadas por propósito, não por fornecedor: cada propósito aponta para um provedor com fallback, os prompts ficam em cache onde o provedor permite e cada chamada é medida em tokens, com o custo registrado por tentativa, retries incluídos.

Uma resposta só é útil quando é fundamentada. A requisição passa primeiro por um roteamento de intenção tipado, então uma pergunta que tem resposta exata é resolvida com uma consulta nativa sobre os dados do próprio sistema, em vez de um palpite do modelo. O que sobra vai para a recuperação híbrida, BM25 mais embeddings, porque a correspondência léxica pega identificadores e termos exatos que a similaridade vetorial tende a borrar, enquanto os embeddings cobrem as paráfrases que a correspondência léxica deixa passar.

Nada disso muda sem um eval. Um prompt ou modelo candidato roda contra o baseline nos mesmos casos com seed, pareados, e a diferença é julgada com um teste de McNemar, com intervalo de Wilson de 95% sobre cada taxa de aprovação. As checagens determinísticas rodam primeiro; um LLM-as-judge com rubrica só entra onde uma checagem fixa não consegue decidir. Erros de infraestrutura ficam isolados da taxa de aprovação, então um provedor instável nunca é contado como um modelo pior.

A saída também é vigiada, porque um modelo pode ser convencido a repetir o que mandaram ele manter em sigilo. Um canário plantado no prompt denuncia um vazamento assim que aparece numa resposta, e uma guarda de shingles pega sobreposições longas com o prompt mesmo quando a redação muda. As duas checagens são determinísticas e baratas, então rodam em toda resposta, não numa amostra. O hábito vem direto do trabalho de segurança: assumir que a entrada é adversária e checar na fronteira.

Segurança, baixo nível

Cheguei à segurança pelo anti-cheat e pelo anti-abuso em larga escala. O trabalho vivia dentro do pipeline de rede: inspecionar pacotes conforme chegavam e rodar detecção estatística de anomalias sobre milhões de eventos diários. Nesse caminho, um falso positivo pune um usuário legítimo e uma checagem lenta adiciona latência para todo mundo, então cada detector é uma troca entre precisão e custo. Essa troca ainda decide onde eu coloco as checagens em qualquer sistema que desenho.

Cheats raramente aparecem só pela rede, e isso me puxou para baixo na pilha, para a engenharia reversa e a análise dinâmica de baixo nível: decompiladores, firmware e DMA, onde o código lido muitas vezes foi escrito para resistir a ser lido. O sandboxing é a outra metade desse trabalho: executar código não confiável onde ele pode ser observado sem que se confie nele. Continua sendo o jeito mais direto que eu conheço de aprender como um sistema se comporta de fato, e não como a documentação diz que ele se comporta.

Hoje a maior parte disso vai para testes ofensivos de aplicações web e APIs, onde autorização quebrada e injeção ainda são as primeiras coisas a procurar. As funcionalidades com LLM abriram uma superfície nova, então eu também analiso bypasses de guardrails: as entradas que fazem um modelo ignorar as próprias instruções ou vazá-las. Essa análise é o motivo de existirem o canário de vazamento de prompt e a guarda de shingles. Defesas ficam mais fáceis de desenhar depois que você quebrou o que elas protegem.

As certificações seguem o mesmo caminho: BSCP, MCP Security, API Penetration Testing, API Security for PCI Compliance e API Security for Connected Cars and Fleets. Eu as leio menos como credenciais e mais como um mapa de onde passei meu tempo, da exploração web ao protocolo que os agentes usam para alcançar suas ferramentas. Elas também explicam escolhas feitas em outras partes desta página: fechado por padrão, credenciais criptografadas, definições de ferramentas fixadas e chamadas arriscadas atrás de uma aprovação.

Em outros lugares

Código, histórico e notas curtas.