🚀 Implementação e Deployment

Backend padrão que executa código Python e shell diretamente no host onde o Hermes roda — sem container, VM ou rede separada.

É o backend de partida para desenvolvimento e debug. Latência zero, acesso direto a arquivos locais e GPUs.

--backend local, isolamento zero, risco de side-effects, ideal para protótipos e CI local.

Cada execução de código vai para um container Docker dedicado, com FS, rede e processos isolados.

É o backend recomendado para produção self-hosted: reproduzível, descartável e bloqueia escapes triviais.

Dockerfile do sandbox, volumes, --network none, limites de CPU/MEM, lifecycle do container por sessão.

Envia comandos via SSH para uma máquina remota — bare-metal, EC2, droplet ou nó HPC.

Útil quando o agente roda em um laptop mas precisa executar em servidor com GPU, ou em ambientes corporativos sem Docker.

Chave SSH, usuário dedicado, ~/.ssh/config, jump hosts, persistência via tmux/screen.

Backend que despacha código para a plataforma Modal — sandboxes serverless com GPUs sob demanda.

Quando o agente precisa de A100/H100 sem manter cluster próprio. Cold-start ~2s, billing por segundo.

MODAL_TOKEN_ID, imagens versionadas, snapshots, quotas, billing por segundo de GPU.

Backend que usa o Vercel Sandbox para executar código em microVMs efêmeras na edge.

Ideal para chatbots web — startup ~300ms, cobra só pelo tempo ativo, sem infra para manter.

VERCEL_TOKEN, runtime Node/Python, timeout 5min, sem persistência entre invocações.

Singularity (Apptainer) roda em clusters HPC sem root; Daytona orquestra workspaces de dev reproduzíveis.

Singularity destrava clusters universitários/SLURM; Daytona dá ao agente um workspace versionado por tarefa.

SIF images, integração com SLURM, workspaces Daytona, devcontainer.json, snapshots.

O sample expõe um único API Gateway que recebe webhooks de Telegram/Slack/Discord/Feishu, encaminha para um Lambda router e invoca o AgentCore Runtime que hospeda o main.py do Hermes.

É a referência canônica para colocar Hermes em produção AWS com TLS, IAM e observabilidade nativas.

API Gateway HTTP API, Lambda router, AgentCore Runtime, CloudWatch logs unificados.

O AgentCore Runtime instancia uma microVM Firecracker dedicada por sessão de usuário, isolamento de hypervisor com cold-start em ~125ms.

É o que torna o sample seguro para multi-tenant — código gerado pelo modelo nunca toca a VM de outro user.

jailer Firecracker, session ID, snapshot/restore, billing por minuto-VM ativo.

O sample divide a infra em 4 stacks CDK: NetworkStack, IamStack, AgentCoreStack, IntegrationsStack.

Stacks separados permitem destruir só as integrações sem refazer VPC ou IAM — economia de tempo em iterações.

cdk deploy --all, ordem de dependências, outputs cross-stack, cdk.context.json.

Como microVMs são efêmeras, o sample persiste histórico de conversa, memórias e arquivos em um bucket S3 particionado por user_id/session_id.

É o padrão que permite agentes "lembrarem" entre mensagens sem manter VM viva — economia de 90% vs sempre-ligado.

S3 prefix por sessão, lifecycle policies, KMS encryption, point-in-time recovery.

Uma Lambda única recebe payloads de Telegram, Slack, Discord e Feishu, normaliza para um schema interno e invoca o AgentCore.

Centraliza autenticação de webhooks, rate limiting e logging — adicionar canal novo = só implementar o adapter.

Webhook signature verification, idempotency, async invoke, dead-letter queue.

Soma de Lambda invocations + AgentCore minutos-VM + S3 storage + API Gateway requests + CloudWatch logs.

Saber a curva real evita surpresa no fim do mês — AgentCore minutes é o item que mais escala com uso.

AWS Cost Explorer, budgets+alerts, tags por canal, escolha de região (us-east-1 mais barato).

Os três sinais que compõem observabilidade moderna: eventos discretos (logs), séries temporais agregadas (métricas) e timeline multi-serviço (traces).

Cada turno do Hermes envolve LLM call + tool + sandbox; só os 3 juntos respondem "o que aconteceu, com que frequência, e onde está o gargalo".

RED (Rate/Errors/Duration), USE (Utilization/Saturation/Errors), correlation via trace_id.

Padrão CNCF (SDK + collector) para emitir telemetria. Instrumenta uma vez, troca o backend sem mudar código.

É a maneira vendor-neutral de instrumentar o Hermes — Tempo, Jaeger, Datadog, Honeycomb falam OTLP.

TracerProvider, BatchSpanProcessor, OTLP gRPC, auto-instrumentação de httpx/openai.

Frontend único com 3 datasources (Prometheus, Loki, Tempo) e dashboards de Overview, Per-User e Cost.

Dashboards prontos reduzem MTTR — quem olha 3 painéis bem desenhados resolve mais rápido que quem grep'a log.

PromQL para RED, heatmaps, drill-down para Tempo, templates do grafana.com (ID 20100).

Promessa numérica (P95 < 3s, error < 1%, custo/req < $0.02) em janelas rolling com error budget definido.

Sem SLO, alertas viram ruído; com SLO, alertas atacam só quando o budget queima rápido.

SLI vs SLO, error budget, burn rate multi-window, Sloth/Pyrra para geração de regras.

Roteamento por severidade (page vs ticket) via Alertmanager para ntfy, Discord webhook ou PagerDuty.

Alerta sem ação é ruído; cada alerta precisa de severidade clara, runbook e owner.

burn-rate alerts, repeat_interval, runbook annotation, cardinality bomb (NUNCA user_id em label).

Árvore com timing exato de cada span: webhook → router → 3 LLM calls → sandbox → tool → S3.

Reduz MTTR de horas para minutos: heatmap mostra a tool culpada, trace confirma a root cause em segundos.

trace_id propagação, log↔trace correlation, Grafana Tempo, span attributes.

7 estágios canônicos: lint, unit, eval, security, build, deploy staging, deploy prod com canary.

Cada estágio é um quality gate; ordenação correta faz pipeline falhar rápido e barato.

Fail fast, artefato imutável, deploy declarativo, concurrency groups.

Suite de avaliação (promptfoo/Inspect) que roda casos representativos medindo fidelidade, safety e latência.

Teste unit não pega regressão de prompt; eval bloqueia PR que degrada qualidade semântica.

Pass rate, regression delta, cost per eval, llm-rubric assertions.

3 scans obrigatórios em todo PR: dependências (pip-audit), secrets (gitleaks), SAST (bandit/Semgrep).

Rápidos e baratos; o custo de não ter é uma chave AWS no histórico do git.

SARIF upload, ::add-mask::, OIDC para credenciais, scan no PR e no main.

Dockerfile multi-stage (builder + runtime slim) + buildx multi-arch (amd64+arm64) + push ECR/GHCR.

Imagem menor = cold start mais rápido; arm64 destrava Graviton (~20% mais barato).

buildx QEMU, cache-from/to gha, provenance + SBOM, healthcheck no Dockerfile.

Canary (5% → 25% → 100%) com SLO watch entre etapas é o default sensato; B/G é overkill para stateless.

Reduz blast radius — quando algo dá errado, só 5% dos usuários veem.

ECSCanary10Percent5Minutes, feature flags, healthcheck profundo, janela diurna.

CodeDeploy/Argo/Spinnaker faz auto-revert quando alarm CloudWatch dispara (error, latência, sandbox fail).

Reverter em <2 min > diagnosticar em >30 min. Treine como game day mensal.

--auto-rollback-configuration, alarms compostos, deployment group, post-deploy SLO watch.