DOM 1 – 4 CaaS Praezidium — Blueprint (Dominios 1–4)

CaaS Praezidium — Blueprint (Entrega 1: Dominios 1–4)

Documento generado: Módulos iniciales (Multi‑tenancy, Onboarding, Screening, Transaction Monitoring). Cada dominio incluye: ADRs referenciadas, tareas, riesgos principales, mitigantes, criterios de aceptación, agentes/sub‑agentes, estructura de agentes, stack recomendado, epics e historias.

Dominio 1 — Multi‑Tenancy, IAM y Despliegue Federado

ADR‑004 / ADR‑005 / ADR‑001

Objetivo: Diseñar un Control Plane y Tenant Factory que permita operar como SaaS multi‑tenant desde el día uno, con opciones de entornos dedicados y nodos privados (edge) para clientes sensibles.

ADRs relevantes

  • ADR‑004 (Tenancy & Deployment) — Multi‑tenant por defecto; soporte para entornos dedicados y despliegues privados. Aislamiento lógico obligatorio.
  • ADR‑005 (Tenant Federation) — Soporte para relaciones parent/child con políticas compartidas opcionales.
  • ADR‑001 (Regulator Evidence Gateway) — Acceso regulador por evidencia y casos, no por acceso total.

Tareas (Mínimo viable)

  • Definir modelo de tenancy: tenant_id, tenant_metadata, tenant_keys (no inventar nombres de columnas en código aún).
  • Implementar Tenant Factory API: crear/activar/desactivar/clone tenant (idempotente).
  • Diseñar y desplegar IAM con SSO (SAML/SCIM/OIDC) + RBAC + ABAC extensible.
  • Implementar KMS por tenant (segregación de claves) y vaulting de secretos.
  • Políticas de red y opcional VPC peering para tenants dedicados; plantilla IaC (Terraform/CloudFormation).
  • Auditoría de aprovisionamiento: every API call → immutable audit event.

Riesgos principales

  • Fuga de datos entre tenants por fallos de particionado lógico o configuración RBAC.
  • “Noisy neighbor” que degrade rendimiento global.
  • Errores de provisión que expongan llaves o credenciales.
  • Regulator requests mal limitadas (acceso a datos fuera del caso solicitado).

Mitigantes

  • Row‑level security + encryption-at-rest con keys por tenant (Vault/KMS).
  • Entornos dedicados para clientes de riesgo alto (network isolation + dedicated clusters).
  • End‑to‑end automated tests en CI que validen aislamiento tras cada cambio.
  • Implementar Supervisory Evidence Gateway (scoped access tokens, timeboxed, read‑only, case‑scoped auditing).

Criterios de aceptación (MVP)

  • API de creación de tenant devuelve tenant_id y material criptográfico; operación idempotente.
  • SSO (OIDC/SAML) configurado y probado con 1 proveedor (Google Workspace) y SAML partner demo.
  • Registros de auditoría inmutables (append-only) para operaciones de tenant provisioning.
  • Pruebas de aislamiento (penetration tests básicos) sin fuga entre 2 tenants.

Agentes & Sub‑agentes (Estructura)

Master Orchestrator (supervisor)

Encargado de orquestar provisioning, políticas y failover.

Tenant Factory Agent

Automatiza creación/clone/deprovision. Emite eventos a la cola de auditoría.

IAM Agent

Gestión de roles, SSO, SCIM provisioning, MFA enforcement.

Billing & Metering Agent

Cuenta de uso por tenant, consumo de créditos, límites.

Stack tecnológico recomendado

Infra & Orquestación

  • Kubernetes (EKS/GKE/AKS) + ArgoCD / Flux (GitOps)
  • Terraform para IaC (plantillas multi‑cloud)
  • Service mesh (Istio / Linkerd) para políticas de malla

IAM & Secrets

  • Keycloak / AWS Cognito / Azure AD B2C (SSO, SAML)
  • HashiCorp Vault / Cloud KMS para claves por tenant

Epics & Historias (ejemplos)

Epic: Tenant Provisioning

  • User Story: Como operador quiero crear un tenant vía API para poder onboardear clientes rápidamente.
  • User Story: Como SRE quiero que la provisión sea idempotente para evitar duplicados.

Epic: IAM Enterprise

  • User Story: Como administrador quiero configurar SAML para un cliente corporativo.
  • User Story: Como auditor quiero ver la lista de roles y el historial de cambios.

Dominio 2 — Onboarding Inteligente (KYC / KYB / Beneficiario Final)

ADR‑006 / ADR‑003

Objetivo: Implementar flujos de captura de identidad, verificación documental y KYB con trazabilidad del beneficiario final desde fase inicial (MVP) con Human‑in‑the‑loop (HiTL).

ADRs relevantes

  • ADR‑006 — Soporte para personas físicas y morales (UBO) desde Phase 1.
  • ADR‑003 — La IA asiste; la decisión legal final es del Oficial de Cumplimiento.

Tareas clave

  • Diseñar expediente electrónico (case file) con evidencias versionadas.
  • Integrar proveedores de validación documental (Jumio/Onfido o alternativas locales).
  • OCR y extracción estructurada (ID, RFC, CURP, datos fiscales).
  • Implementar flujo de KYB: registro de sociedad, constitución, RFC, actos inscritos.
  • Motor de inferencia UBO: relaciones societarias + graph builder para ownership chains.
  • Módulo HiTL: cola de revisión manual, SLA de revisión, anotaciones forenses.

Riesgos principales

  • Documentos falsificados no detectados.
  • Errores en extracción que generan datos incorrectos (DOB, RFC).
  • Exposición innecesaria de PII por retención inadecuada.

Mitigantes

  • Integrar múltiples verifications (document + selfie + liveness) y score combinado.
  • Almacenamiento cifrado de evidencias y retención reglamentada configurable por tenant.
  • Reglas de calidad de OCR y validación cruzada con fuentes públicas (SAT, Registro Público).
  • Flows de apelación y re‑revisión humana con trazabilidad.

Criterios de aceptación (MVP)

  • Flujo KYC individual end‑to‑end: capture → doc verify → selfie/liveness → status (verified/manual).
  • KYB mínimo: registrar entidad, cargar constitución y RFC, primer nivel de UBO detectado y graph inicial.
  • Expediente con evidencia PDF generado y firmado digitalmente (hash) listo para auditoría.

Agentes & Sub‑agentes

Onboarding Agent (Orquestador)

Coordina flujos, encola verificaciones y gestiona SLA HiTL.

Doc Verification Sub‑agent

Hace llamadas a proveedores, normaliza respuestas y produce evidencia.

UBO Inference Agent

Construye grafo de ownership y sugiere beneficiarios con nivel de confianza.

Case File Agent

Compone el expediente, firmarlo y gestionar versiones.

Stack tecnológico recomendado

Verificación & OCR

  • Proveedor IDV (Onfido/Jumio) o proveedor local compatible
  • Motor OCR: Google Vision / AWS Textract / Tesseract para fallback

Persistencia & Graph

  • Object storage: S3/MinIO para evidencias
  • Graph DB: Neo4j / Amazon Neptune para ownership graph
  • Metadata store: PostgreSQL con RLS (row level security)

Epics & Historias (ejemplos)

Epic: KYC Persona Física

  • Story: Como cliente quiero subir mi ID y selfie para verificar mi identidad en < 10 minutos.
  • Story: Como analista quiero ver el score combinado y los motivos de rechazo.

Epic: KYB y UBO

  • Story: Como oficial quiero importar una constancia de situación fiscal y que el sistema sugiera UBOs.
  • Story: Como auditor quiero ver la trazabilidad completa de la inferencia UBO (evidencias y fuentes).

Dominio 3 — Screening: Sanciones, PEPs y Adverse Media

ADR‑001 / ADR‑003

Objetivo: Proveer capacidades de screening robustas, explicables y actualizables, con reglas de descarte y flujo HiTL para evitar decisiones automáticas no auditadas.

ADRs relevantes

  • ADR‑001 — Regulador accede solo a evidencias y casos.
  • ADR‑003 — AI asistente; decisión final humana.

Tareas mínimas

  • Integrar feeds: OFAC, UN, EU, local (UIF Mexico) y listas comerciales (World‑Check/ComplyAdvantage).
  • Implementar motor de matching con soporte fuzzy, fonético y transposition matching (apellidos compuestos, tildes).
  • Implementar reglas de descarte/aceptación (usar plantilla de reglas descarte screening.xlsx como fuente).
  • Registrar evidencia: snapshot de la lista + parámetros de matching (algoritmo, umbral).
  • Adverse Media: ejecutar búsquedas de noticias (adverse media) y enlazar evidencias al perfil.

Riesgos principales

  • Matches falsos por homonimia o datos parciales.
  • Feeds desactualizados o corruptos.
  • Decisiones automáticas sin evidencia suficiente que causen impacto reputacional o legal.

Mitigantes

  • Versionado de feeds y comprobación de integridad (hash) al ingest.
  • Implementar reglas de descarte (confidence thresholds + evidence requirements) y mantener registro de la regla aplicada (audit trail).
  • Human review workflows y tiempo‑boxed escalations para true matches.
  • Mecanismo de apelación y corrección con trazabilidad.

Criterios de aceptación (MVP)

  • Ingest de al menos 3 feeds sancionatorios y programación automática de refresh (daily/real‑time según feed).
  • Motor de matching que exponga: matched_fields, match_score, algorithm_used y snapshot de la fuente.
  • Implementación inicial de reglas de descarte (basado en archivo “reglas descarte screening.xlsx”).

Agentes & Sub‑agentes

Screening Orchestrator

Gestiona ejecuciones de screening y consolida resultados.

Sanctions Sub‑agent

Consulta y normaliza feeds sancionatorios.

PEP Sub‑agent

Mantiene y actualiza listas PEP + relaciones públicas.

Adverse Media Agent

Ejecuta búsquedas en Open Web / News APIs y clasifica relevancia.

Stack tecnológico recomendado

Index & Matching

  • Elasticsearch / OpenSearch para indexado y scoring
  • Name matching libs (FuzzyWuzzy / trigrams / phonetic algorithms)

Feeds & Enrichment

  • Proveedor de listas: ComplyAdvantage / World‑Check (si contratado)
  • News APIs (GDELT / MediaCloud / proveedor comercial) para adverse media

Epics & Historias (ejemplos)

Epic: Ingest & Versionado de Feeds

  • Story: Como SRE quiero que el ingest de feed registre versión y hash para reproducibilidad.
  • Story: Como analista quiero ver el snapshot de la fuente que disparó el match.

Epic: Motor de Matching Explicable

  • Story: Como oficial quiero ver qué campos coincidieron y qué algoritmo produjo el score.
  • Story: Como analista quiero aplicar una regla de descarte y que quede registrada.

Dominio 4 — Transaction Monitoring (TMS) & Integración de Orígenes

ADR‑002 / Sprint‑4 (Roadmap)

Objetivo: Construir pipeline de ingest de transacciones, normalización, reglas + ML, mapeo a tipologías (Typology Engine) y generación de alertas / casos con trazabilidad para SAR/STR.

Tareas críticas

  • Catalogar adaptadores de entrada: SPEI, tarjetas, transferencias bancarias, pasarelas de pago, cripto (exploratorio).
  • Normalización de eventos financieros (canonical schema) y enriquecimiento (KYC link, geolocation, device fingerprint).
  • Motor de reglas tradicional + ML scoring (anomalies) y mapeo a tipologías (Dom.5 later integra inferencia).
  • Implementar backpressure y circuit‑breakers en adaptadores de alta tasa.
  • Sistema de alertas → Case Manager (expediente) y feedback loop (analyst verdict → tune rules/models).

Riesgos principales

  • Altos volúmenes que generan latencia no aceptable (falso negativo por throttling).
  • Alert fatigue por reglas mal calibradas → pérdida de atención humana.
  • Ingest inconsistente de metadatos (pérdida de trazabilidad).

Mitigantes

  • Arquitectura basada en eventos (Kafka) con procesamiento en stream (Flink / ksqlDB) y almacenamiento frío para auditoría.
  • Capas de pre‑filtro y scoring para reducir FP (rules first, luego ML + typology matching).
  • Exponer métricas (Prometheus + Grafana) y alertas SRE para latencia y backlogs.

Criterios de aceptación (MVP)

  • Conector funcional a al menos 1 origen (ej. SPEI feed o archivo CSV de transacciones) y pipeline end‑to‑end.
  • Reglas configurables por UI que generen alertas, con link directo al expediente del cliente (KYC).
  • Capacidad de procesar un throughput de referencia (por ejemplo, 100 tx/s para mercado inicial) con degradación controlada.

Agentes & Sub‑agentes

Transaction Ingestor Agent

Normaliza eventos y los publica a la cola de procesamiento.

Rule Engine Agent

Evalúa reglas determinísticas y prioriza alertas.

ML Scoring Agent

Aplica modelos de anomalía y riesgo dinámico.

Typology Matching Agent (integra Dom.5)

Relaciona patrones con la base de tipologías; devuelve matched_typology con confianza.

Stack tecnológico recomendado

Streaming & Storage

  • Kafka / Confluent o PubSub
  • Flink / ksqlDB para stream processing
  • ClickHouse / Timescale / BigQuery para análisis histórico

ML & Orquestración

  • SageMaker / Vertex AI / MLflow para modelos; model registry
  • Feature store (Feast o equivalente) para features transaccionales

Epics & Historias (ejemplos)

Epic: Ingest & Normalization

  • Story: Como integrador quiero subir un CSV de SPEI y validarlo para que el pipeline lo consuma.
  • Story: Como SRE quiero que el ingestor valide esquema y emita métricas de tasa y errores.

Epic: Rule Authoring & Alerting

  • Story: Como analista quiero crear y activar una regla “monto > X y cliente nuevo” desde UI.
  • Story: Como oficial quiero recibir SAR draft pre‑llenado con evidencias asociadas a la alerta.
DOM 5 – 8 CaaS Praezidium — Blueprint (Dominios 5–8)

CaaS Praezidium — Blueprint (Entrega 2: Dominios 5–8)

Esta entrega cubre: Dominio 5 (Tipologías e Inferencia), Dominio 6 (Dynamic Risk Rating & EWRA), Dominio 7 (Reporting Engine y Narrativas AI) y Dominio 8 (Master Orchestrator y Estructura de Agentes). Cada dominio incluye: ADRs, tareas, riesgos/mitigantes, criterios de aceptación, agentes/sub‑agentes, stack tecnológico, epics e historias.

Dominio 5 — Tipologías & Pattern Recognition (Typology Engine)

ADR‑006 / Sprint‑0 / Tipology KB

Objetivo: Ingestar, normalizar y operacionalizar las tipologías (archivos CSV: tipologias matriz operativa.csv, tipologias globales.csv) en una Knowledge Base versionada que el motor de inferencia use para mapear alertas/transacciones a tipologías con estrategias de razonamiento (abducción, inducción, analogía, etc.).

ADRs relevantes

  • ADR‑006 — Tipologías desde Sprint 0; mapping de señales (señal_de_alerta_clave) → reglas detectables.
  • ADR‑003 — Resultado de inferencia asistido, verificado por humano para decisión final.
  • ADR‑001 — Cada tipología referenciará fuentes (FATF/GAFILAT/UIF) y deberá citar origen en reportes.

Tareas (MVP → iteraciones)

  • Ingestar los CSV proporcionados; crear pipeline ETL que normalice columnas y detecte campos clave (tipologia, señal_de_alerta_clave, fase_lavado, delito_precedente, herramienta_deteccion).
  • Diseñar esquema de Knowledge Base: nodes (tipología, señal, sector, producto, fuente) + relations; persistir en Graph DB.
  • Construir index RAG: embeddings de descripciones/nota → vector DB y documentos referenciales (PDF/URL).
  • Implementar motor de inferencia con módulos: Abduction, Induction, Analogy, Probabilistic Ranking, Typicality Heuristics.
  • Mapear cada regla/red flag a una regla técnica detectable (ej.: “margen reventa >200%” → rule: unit_price_ratio > 2.0 con soporte documental).
  • Crear Typology Curator UI para editar, versionar y aprobar nuevos patrones (workflow de cambio con PR + audit trail).

Riesgos principales

  • Overfitting de inferencias: sistema sugiere tipologías demasiado específicas para ruido.
  • Falta de trazabilidad en la inferencia (punto clave para auditoría regulatoria).
  • Tipologías desactualizadas o con errores introducidos por curadores.

Mitigantes

  • Versionado obligatorio de tipologías y rollback automático a la última versión firmada.
  • Every inference returns: matched_signals[], inference_strategy, confidence_score, provenance (source ids, csv row hash).
  • Test suites (unit + integration) que validan inferencias sobre un corpus de casos etiquetados.
  • Human‑in‑the‑loop gating: thresholds que obligan revisión manual si confidence < X o si tipología es crítica.

Criterios de aceptación (MVP)

  • KB inicial ingestada desde los 2 CSVs y expuesta vía API (search / query / get_tipologia).
  • RAG index accesible y testado: query que devuelve top‑k tipologías con fuentes y embeddings.
  • Motor de inferencia entrega matched_typology object con fields: confidence, inferred_phase, cited_sources.

Agentes & Sub‑agentes (Estructura)

Typology Orchestrator (Dominio)

Controla ingestion, versioning y publicación de tipologías.

KB Manager Sub‑agent

Gestiona Graph DB y sincronización con vector DB.

Reasoning Engine (Sub‑agent)

Ejecuta estrategias: Abduction, Induction, Analogy y devuelve ranked hypotheses.

Curator Agent

Workflow de edición/approbación de tipologías con audit trail.

Stack tecnológico recomendado

Knowledge & Retrieval

  • Graph DB: Neo4j / Amazon Neptune
  • Vector DB: Weaviate / Pinecone / Milvus
  • Embeddings: OpenAI / local open models (Llama2 embedding models)

Reasoning & RAG

  • LangChain / LlamaIndex for RAG orchestration
  • Custom rules engine + probabilistic scoring (Pyro / scikit‑learn)

Epics & Historias (ejemplos)

Epic: KB Ingest & Versioning

  • Story: Como ingeniero quiero que al subir un CSV el sistema normalice y proponga mapeos automáticos.
  • Story: Como curador quiero aprobar una nueva tipología y que quede versionada con hash y firma.

Epic: Inference API

  • Story: Como Typology Agent quiero recibir una alerta con transacción y recibir una lista de hipótesis con confianza.
  • Story: Como analista quiero ver la cadena de razonamiento (evidencias + estrategia de inferencia) para cada hipótesis.

Dominio 6 — Dynamic Risk Rating & Early‑Warning Risk Assessment (EWRA)

ADR‑002 / Risk‑By‑Design

Objetivo: Definir y operar un motor de scoring que combine factores estáticos (perfil, sector, jurisdicción) y dinámicos (comportamiento transaccional, typology matches, screening hits) para producir un Risk Score auditable y un EWRA con triggers operativos.

ADRs relevantes

  • ADR‑002 — Priorizar segmentos objetivo y calificar riesgos por cliente/entidad.
  • ADR‑001 — Todos los scores deben ser explicables y auditablemente referenciables.

Tareas principales

  • Definir taxonomía de factores de riesgo (jurisdicción, producto, sector, UBO risk, sanctions hits, typology matches, anomaly score).
  • Implementar pipeline de features en Feature Store (latency, rolling windows, aggregates).
  • Desarrollar Risk Scorer: reglas determinísticas (policy layer) + ML model (calibrado) para score continuo.
  • Diseñar EWRA: umbrales, escalation matrix, SLA de respuesta, notificaciones automatizadas.
  • Incluir explainability: per‑score SHAP/feature importances + human readable justification templates.

Riesgos principales

  • Scores no explicables que impidan decisiones regulatorias o lleven a disputas con clientes.
  • Bias en modelos que penalicen colectivos por datos históricos sesgados.
  • Desalineación entre reglas de negocio y modelos ML (inconsistencia).

Mitigantes

  • Hybrid approach: reglas de negocio preceden modelos; modelos sólo ajustan el scoring dentro de bounds definidos.
  • Model governance: registro en model registry, retraining cadence, fairness checks y dataset lineage.
  • Explainability obligatorio: every score includes the top 5 drivers and a textual rationale for analysts.

Criterios de aceptación (MVP)

  • Risk Score calculado para un cliente a partir de N factores (static + dynamic) y expuesto vía API.
  • EWRA produce alerts cuando score > threshold y dispara un caso en el Case Manager con evidencia.
  • Reportes de explainability disponibles para cada score generado (feature contributions).

Agentes & Sub‑agentes

Risk Scorer Agent

Combina reglas de negocio y modelos ML para producir score y drivers.

EWRA Engine

Evalúa thresholds, aplica escalamiento y gestiona notificaciones/SLA.

Feature Store Manager

Prepara y sirve features en baja latencia para scoring en línea y batch.

Model Governance Agent

Registra versiones, métricas de performance y prueba de fairness.

Stack tecnológico recomendado

Feature & Model infra

  • Feature store: Feast / Tecton (o internal store con Redis + materialized views)
  • Model registry: MLflow / Vertex AI Model Registry
  • Explainability: SHAP / ELI5

Operational

  • Real‑time serving: KFServing / Seldon or serverless endpoints
  • Alerting: n8n or event-driven orchestration to push to Case Manager

Epics & Historias (ejemplos)

Epic: Risk Scoring Engine

  • Story: Como oficial quiero ver el Risk Score y sus principales drivers para un cliente.
  • Story: Como SRE quiero endpoints de scoring con SLA < 200ms para requests en línea.

Epic: EWRA & Escalation

  • Story: Como analista quiero recibir una alerta EWRA con prioridad y acciones recomendadas.
  • Story: Como auditor quiero extraer la historia completa de escalaciones por tenant.

Dominio 7 — Reporting Engine: SAR/STR / Document Composer y Narrativas AI

ADR‑001 / ADR‑007 (GTM usage)

Objetivo: Generar borradores estructurados de reportes regulatorios (SAR/STR/ROS/CTR) y paquetes de evidencia que respeten jurisdicciones y cumplan requisitos mínimos formales; la generación asistida por AI debe incluir RAG con citas y pruebas, y siempre estar sujeta a aprobación humana.

ADRs relevantes

  • ADR‑001 — Evidencia y trazabilidad para reguladores; no exponer datos fuera del alcance del caso.
  • ADR‑003 — IA sugiere lenguaje, el Oficial de Cumplimiento aprueba y firma.
  • ADR‑007 — GTM y posición comercial para mensajes de producto vs servicio.

Tareas críticas

  • Definir templates legales por jurisdicción (CNBV/UIF, FinCEN, EU formats) y metadatos obligatorios.
  • Implementar RAG‑driven narrative generator que cite fuentes (tipologías, feeds, transacciones) y adjunte evidencia (PDF hashes, screenshots).
  • Generar paquete listo para envío: PDF firmado, metadatos machine‑readable (JSON) y log de aprobaciones.
  • Registrar envíos y respuestas regulatorias en el expediente (evidence pack) con timestamps y hash.
  • Integrar firma digital / e‑sign (Docuseal / DocuSign) y preparar export para portales regulatorios (CSV, XML según necesidad).

Riesgos principales

  • Redacción inexacta o insuficiente que derive en sanción/consulta por parte del regulador.
  • Filtración de PII/confidencialidad al generar documentos o enviarlos por canales inseguros.
  • Dependencia excesiva en versiones de modelos o prompts no auditables.

Mitigantes

  • Always human approval: bloqueo de envío hasta que un Oficial firme el reporte.
  • RAG with provenance: cada frase generada por AI debe poder enlazarse a un fragmento de evidencia (feed id, csv row, transaction id).
  • Redaction engine para PII según políticas tenant (masking/selective disclosure) antes de empaquetar el envío.
  • Sandboxed generator con prompt templates versionadas y pruebas de calidad continuas.

Criterios de aceptación (MVP)

  • Generación de un SAR draft pre‑llenado (PDF + JSON metadata) que contenga: descripción del evento, evidencias referenciadas y TL;DR de razones que justifican el envío.
  • Workflow de aprobación: create → review → sign → send (manual send or export).
  • Logs de versión y hash de documento disponibles para auditoría.

Agentes & Sub‑agentes

Reporting Agent (Orquestador)

Coordina composición de SAR/STR, aplica templates y controla el proceso de aprobación.

Narrative Generator Sub‑agent (RAG)

Usa vector DB + LLM para redactar borradores enlazando evidencias.

Evidence Packager

Compone y firma paquetes, aplica redaction policies y genera export.

Regulator Adapter

Prepara formato de envío según jurisdicción y mantiene logs de comunicación.

Stack tecnológico recomendado

Generation & Docs

  • LLM orchestration: LangChain / LlamaIndex
  • PDF/Docx generation: Pandoc / python-docx / WeasyPrint
  • Digital signing: Docuseal or cloud KMS signing

Provenance & Storage

  • Vector DB + Knowledge KB (Ver dominio 5)
  • Object storage (S3/MinIO) + immutable audit log (append-only ledger)

Epics & Historias (ejemplos)

Epic: SAR Drafting Automation

  • Story: Como analista quiero un borrador producido por AI que incluya citas a transacciones y tipologías.
  • Story: Como Oficial quiero poder editar y firmar el borrador antes de su envío.

Epic: Regulator Send & Tracking

  • Story: Como compliance manager quiero exportar en formato compatible con UIF Mexico y guardar evidencia del envío.
  • Story: Como auditor quiero extraer el paquete enviado y verificar hashes y versiones.

Dominio 8 — Master Orchestrator & Agent Fabric (Control Plane)

ADR‑001 / ADR‑004 / Orchestrator

Objetivo: Definir el Master Orchestrator (control plane) que registre, enrute y supervise sub‑agentes especializados (Onboarding, Screening, Typology, Risk, Reporting, TMS). Debe ofrecer contratos de comunicación, políticas de retry/timeout, y observabilidad consolidada.

ADRs relevantes

  • ADR‑004 — Control plane must support multi‑tenancy and isolated tenant policies.
  • ADR‑001 — Supervisory Evidence Gateway lives behind orchestrator policies for regulator access.

Tareas esenciales

  • Diseñar Agent Registry: catálogo de agentes, versiones y capabilities (capabilities = what inputs/outputs they accept).
  • Definir standard event schema / contract (trace_id, tenant_id, case_id, timestamp, payload_type).
  • Implementar broker/event bus (Kafka) con topics por dominio y control de tenancy (partitioning).
  • Política de orquestación declarativa (Temporal / Cadence / Argo Workflows) para flows complejos y retries con circuit breakers.
  • Implementar control plane APIs: register_agent, invoke_agent, get_status, cancel_workflow, scale_agent.
  • Observabilidad: tracing (Jaeger), metrics (Prometheus), logs centralizados (ELK/Opensearch).

Riesgos principales

  • Orchestrator como single point of failure si no se diseña en HA.
  • Fallas en contratos entre agentes que causen pérdida de eventos o desincronización (inconsistencias).
  • Riesgo de escalada en cascada: un agente fallando puede saturar otros componentes.

Mitigantes

  • Diseño HA: control plane redundante, leader election, state stored en durable store (etcd / RDBMS).
  • Contracts strictness + schema validation + consumer-side idempotency keys.
  • Backpressure, circuit breakers y bulkheads (isolated threadpools/queues por agent type).
  • Chaos testing y synthetic transactions para validar resiliencia periódicamente.

Criterios de aceptación (MVP)

  • Master Orchestrator despliega y coordina 3 agentes (Onboarding, Screening, TMS) en un flujo demo end‑to‑end (transaction → screening → typology inference → case creation).
  • Event schema validado y trazabilidad completa (trace_id) desde ingest hasta case closure.
  • Dashboards básicos de salud y métricas disponibles (latency, error rates, queue depth).

Agentes & Estructura (Control Plane)

Master Orchestrator

Planea y ejecuta workflows; mantiene Agent Registry; aplica políticas de tenancy y gobernanza.

Domain Orchestrators (one per domain)

P. ej. Screening Orchestrator, Typology Orchestrator — responsables de coordinar sub‑agentes dentro del dominio.

Agent Control Plane

Autoscaling, health checks, version rollout, canary deployments.

Policy Engine (OPA)

Evalúa ABAC/RBAC policies, access to evidence and throttling rules.

Stack tecnológico recomendado

Orchestration & Broker

  • Temporal / Cadence / Argo Workflows for durable orchestrations
  • Event Bus: Kafka / Confluent (multi‑tenant partitions)
  • Service Mesh: Istio / Linkerd for secure inter‑agent comms

Policy & Observability

  • Policy: OPA (Open Policy Agent) with Rego policies stored per tenant
  • Tracing: Jaeger; Metrics: Prometheus + Grafana; Logs: ELK / OpenSearch

Epics & Historias (ejemplos)

Epic: Agent Fabric & Registry

  • Story: Como arquitecto quiero registrar un nuevo agent con sus contracts para que pueda ser invocado por el Orchestrator.
  • Story: Como SRE quiero desplegar una nueva versión de un sub‑agent con canary rollout y rollback automático.

Epic: Workflow Examples

  • Story: Como producto quiero un workflow “Onboard → Screen → Score → Create Case” reproducible y versionado.
  • Story: Como auditor quiero poder reproducir la ejecución de un workflow con todos los eventos y payloads.
DOM 9 – 12 CaaS Praezidium — Blueprint (Dominios 9–12)

CaaS Praezidium — Blueprint (Entrega 3: Dominios 9–12)

Esta entrega cubre: Dominio 9 (LMS & Capacitación), Dominio 10 (Auditoría & Logs Inmutables), Dominio 11 (Feeds Externos & Cambios) y Dominio 12 (Data Governance & Model Lineage). Cada dominio incluye: ADRs, tareas, riesgos/mitigantes, criterios de aceptación, agentes/sub‑agentes, stack tecnológico, epics e historias.

Dominio 9 — Learning Management System (LMS) & Staff Training

ADR‑002 / ADR‑003

Objetivo: Proporcionar capacitación continua e inteligente para el staff de cumplimiento de los clientes (Oficiales, Analistas, Soporte), con cursos sobre PLD/FT, tipologías, herramientas, y auditoría interna. Debe incluir tracks personalizados por rol, progreso medible y certificación digital.

ADRs relevantes

  • ADR‑002 — Segmento inicial: profesionales y pequeñas instituciones con necesidad de educación básica.
  • ADR‑003 — Certificación de conocimiento es un paso previo a tomar decisiones legales.

Tareas mínimas

  • Definir tracks de aprendizaje: Introductorio, Avanzado, Especialista (por temas: Crypto, TBML, Tipologías).
  • Integrar contenido multimedia: videos, cuestionarios autoevaluables y pruebas de certificación.
  • Diseñar gamification ligera: badges, streaks, leaderboard opcional y avance track por tenant.
  • Implementar LMS UI responsive con SSO integrado (tenant-aware) y soporte offline básico.
  • Emitir certificados con hash firmado digitalmente y persistir en expediente del usuario.
  • Integración con Typology KB: cursos de actualización automática cuando se publica una nueva tipología.

Riesgos principales

  • Bajo engagement: cursos no completados o usados como checkbox.
  • Contenido no alineado con prácticas reales o cambios reglamentarios recientes.
  • Revalidación de certificaciones no automatizada ni auditada.

Mitigantes

  • Microlearning: módulos cortos (5–10 min) centrados en casos prácticos.
  • Notificaciones automatizadas de nuevas tipologías o actualizaciones regulatorias (triggered por n8n).
  • Calendario obligatorio de re-certificación por rol (ej. Oficiales: cada 12 meses).
  • Dashboard con métricas por tenant: % completitud, tasa de aprobación, certificaciones vigentes.

Criterios de aceptación (MVP)

  • Usuario registrado puede acceder al LMS con SSO, completar un curso introductorio y obtener certificado firmado.
  • El sistema registra progreso, tiempo invertido y calificación final en cada módulo.
  • Contenido adaptable por tenant: mostrar solo las normativas jurisdiccionales aplicables.

Agentes & Sub‑agentes

LMS Orchestration Agent

Coordinador del sistema LMS, maneja usuarios, cursos, progreso y emisión de certificados.

Content Delivery Sub‑agent

Sirve videos, PDFs y cuestionarios desde CDN seguro con control de acceso.

Assessment & Certification Agent

Administra evaluaciones, verifica respuestas y emite certificados con firma digital.

Learning Recommender

Sugiere contenidos basados en role, historial, nuevas tipologías y riesgos.

Stack tecnológico recomendado

Plataforma & UX

  • LMS: Moodle / Teachable / custom frontend + headless CMS
  • Frontend: React / SvelteKit / Vue con soporte responsive
  • CDN: CloudFront / Cloudflare para contenido multimedia

Gamification & Backend

  • DB: PostgreSQL (usuarios, progresos, calificaciones)
  • Storage: S3 bucket para videos y recursos
  • Certificates: Firmado con KMS y PDF generator (WeasyPrint)

Epics & Historias (ejemplos)

Epic: Curso Introductorio

  • Story: Como nuevo usuario quiero completar el curso introductorio sobre PLD/FT para entender los fundamentos.
  • Story: Como administrador quiero rastrear quién ha completado qué cursos y ver certificados emitidos.

Epic: Personalización por Tenant

  • Story: Como Oficial quiero ver solo leyes aplicables a mi jurisdicción (MX, US, EU).
  • Story: Como Analista quiero recibir alertas cuando se publique una nueva tipología relevante.

Dominio 10 — Auditoría Inmutable & Logs Seguros

ADR‑001 / Compliance‑First Design

Objetivo: Implementar sistema de logging seguro, inmutable y consultable para todas las operaciones relacionadas con clientes, transacciones, screening, tipologías, decisiones humanas y accesos regulatorios. Debe cumplir con estándares de auditoría como SOC 2 y GDPR.

ADRs relevantes

  • ADR‑001 — Toda acción debe poder ser auditada; logs son append‑only y criptográficamente seguros.

Tareas esenciales

  • Diseñar formato estandarizado de log: tenant_id, case_id, trace_id, timestamp, actor (human/system), action, resource_type, resource_id, metadata (payload_hash).
  • Implementar append-only log store (ej. Chronicle / TimescaleDB hypertables / append-only Kafka topics).
  • Integrar firma criptográfica (hash chaining) o Merkle trees para integridad de logs.
  • Exportación programada de logs para backup y auditoría externa (CSV + JSON + firmado).
  • Query engine eficiente para auditorías (ej. logs desde “transacción X” hasta “decisión final Y”).
  • Retention policy: configurable por tenant, con cumplimiento de 7–10 años según jurisdicción.

Riesgos principales

  • Logs incompletos o alterados que invaliden auditorías.
  • Alto costo de almacenamiento y procesamiento si no hay purga o compresión.
  • Consultas lentas en grandes volúmenes de eventos (millones de registros).

Mitigantes

  • Firmado criptográfico de cada bloque de logs (ej. HMAC o Merkle root por batch).
  • Data lake partitioned por día/mes y compresión automática (parquet).
  • Índices por tenant_id, case_id y trace_id para consultas eficientes.
  • Exports configurables: diarios, semanales, mensuales con hash y firma para auditorías externas.

Criterios de aceptación (MVP)

  • Todo evento en el sistema produce un log firmado con trace_id único y persistido inmutablemente.
  • Se pueden hacer queries por trace_id (ej. toda la cadena de ejecución de un caso).
  • Log exportado a CSV/JSON con firma digital disponible.

Agentes & Sub‑agentes

Audit Logger Agent

Captura, firma y persiste eventos en el log inmutable.

Log Archiver

Comprime, particiona y hace backup automático de logs antiguos.

Integrity Checker

Verifica hash chains periódicamente para detectar alteraciones.

Query Engine

Backend de búsqueda optimizado por trace_id, tenant_id, timestamp, actor.

Stack tecnológico recomendado

Logging & Storage

  • Log Format: JSON con campos estándar + hash firma
  • Store: TimescaleDB / Kafka / Chronicle
  • Compression: Parquet / Snappy para archiving

Security & Query

  • Crypto: HMAC / SHA3 para firma de bloques
  • Query: Elasticsearch / ClickHouse / DuckDB
  • Audit UI: Grafana / custom dashboard para explorar logs

Epics & Historias (ejemplos)

Epic: Log Inmutable

  • Story: Como SRE quiero que cada transacción produzca un evento firmado que no pueda ser alterado.
  • Story: Como auditor quiero exportar logs por tenant entre fechas con firma criptográfica.

Epic: Traceabilidad Completa

  • Story: Como Oficial quiero buscar por trace_id y reconstruir todo el proceso de un caso.
  • Story: Como compliance manager quiero exportar logs por usuario/acción para revisiones internas.

Dominio 11 — Feeds Externos & Change Management

ADR‑001 / Sprint‑0 (Tipology KB)

Objetivo: Diseñar pipelines de ingest automatizados para fuentes externas (tipologías, sanciones, noticias, jurisprudencia, reglamentos) y un sistema de gestión de cambios de datos/versiones con aprobación humana.

ADRs relevantes

  • ADR‑001 — Toda fuente externa debe tener versionado, hash y trazabilidad para auditorías.
  • ADR‑006 — Tipologías deben ser curadas y aprobadas antes de publicarse al motor de inferencia.

Tareas críticas

  • Detectar y conectar fuentes: RSS de UIF México, FATF, GAFILAT, BOE España, SAT, DOF.
  • Diseñar adaptadores modulares: PDF scraper, RSS parser, API connector, web crawler (si necesario).
  • Incorporar mecanismo de diff: comparar nueva versión vs anterior para detectar cambios relevantes.
  • Workflow de aprobación: propuesta → diff → human review → publish → notify stakeholders.
  • Integración con Typology KB (Dominio 5): nueva tipología → notificación a LMS y Orchestrator.
  • Notificación automática a usuarios cuando se publican cambios importantes (newsletter + in‑app).

Riesgos principales

  • Fuentes no confiables o datos mal estructurados que contaminen la KB.
  • Demoras en actualización que generen lag en cumplimiento.
  • Demasiados cambios sin filtrar que generen fatiga en revisores.

Mitigantes

  • Whitelist de fuentes confiables y checksum/hash para verificación de integridad en cada ingest.
  • Scheduler configurable por frecuencia (diaria/semanal) y ventana horaria (evitar picos).
  • Diff highlighting y changelog automático para facilitar revisión por humanos.
  • Notificación selectiva por relevancia (ej. nuevas tipologías nacionales vs cambios menores).

Criterios de aceptación (MVP)

  • Al menos 3 fuentes externas (ej. UIF RSS, FATF reports, GAFILAT summaries) están siendo monitoreadas y ingeridas.
  • Workflow de aprobación permite ver diff, aprobar/rechazar cambios y publicar nueva versión.
  • Notificación se dispara automáticamente a curadores cuando se detecta cambio en una fuente.

Agentes & Sub‑agentes

Feed Orchestrator Agent

Gestiona ingest, schedulers, estado de conectividad y diff detection.

Source Adapters

Plugins modulares para PDF, RSS, API, etc. que extraen datos normalizados.

Change Reviewer Agent

Detecta diferencias y prepara propuesta de cambio para aprobación humana.

Notify Engine

Envía alertas a curadores, LMS y Orchestrator cuando se publica un cambio.

Stack tecnológico recomendado

Ingest & Diff

  • n8n / Airflow para scheduling y pipelines
  • Scrapers: BeautifulSoup / Playwright para crawling
  • Diff lib: difflib / custom parser

Storage & Notification

  • PostgreSQL para staging de nuevos datos
  • Object storage: S3 para archivos originales (PDF, XML)
  • Email / In‑App Notifications: SES + WebSocket o polling

Epics & Historias (ejemplos)

Epic: Feed Ingest & Diff

  • Story: Como curador quiero recibir notificación cuando UIF México publica un nuevo documento.
  • Story: Como analista quiero poder explorar el diff entre versiones y aprobar o rechazar.

Epic: Automatización de Cambios

  • Story: Como arquitecto quiero conectar una nueva fuente RSS en minutos sin código adicional.
  • Story: Como compliance manager quiero recibir reporte semanal del estado de fuentes externas.

Dominio 12 — Gobernanza de Datos & Model Lineage

ADR‑001 / SOC 2 / ISO 27001

Objetivo: Garantizar trazabilidad completa de datos (desde fuente hasta consumidor), políticas de calidad, retención y privacidad, así como linaje de modelos ML (versión, datos de entrenamiento, métricas, bias checks).

ADRs relevantes

  • ADR‑001 — Todo dato debe tener linaje (data lineage), política de retención, y cumplir con protección de datos.

Tareas clave

  • Definir data catalog: datasets, schemas, owners, lineage (origen → transformación → destino).
  • Implementar data quality checks (ej. completeness, uniqueness, referential integrity).
  • Aplicar data minimization: solo persistir lo necesario, con políticas de purga automática.
  • Model lineage: registrar modelo, dataset usado, fecha de entrenamiento, métricas, bias checks.
  • Integrar con IAM: quien puede leer/modificar qué datos, bajo qué condiciones.
  • Exposición de dashboards: calidad de datos, linaje, modelos en producción, drift reports.

Riesgos principales

  • Datos corruptos o incompletos que derivan en decisiones erróneas.
  • Modelos obsoletos en producción sin detección de drift ni actualización.
  • Violación de privacidad o retención indebida de PII.

Mitigantes

  • Data contract testing: validaciones automáticas en ingesta y transformación.
  • Model registry + drift detectors: alerta si performance cae o features cambian.
  • Policies as code: retention, anonymization y consent policies definidas por tenant.
  • RBAC + ABAC en todas las capas: acceso solo a datos autorizados, con logging obligatorio.

Criterios de aceptación (MVP)

  • Catálogo de datos incluye al menos 10 datasets con descripción, schema y linaje.
  • Data quality checks están definidos y corren diariamente, con alertas automáticas.
  • Modelo ML tiene linaje completo: dataset, versión, métricas, fecha de entrenamiento.

Agentes & Sub‑agentes

Data Catalog Agent

Mantiene inventario de datasets, schemas, owners, y linaje.

Data Quality Monitor

Ejecuta checks, reporta errores y alerta a responsables.

Model Linage Tracker

Registra y expone linaje de modelos, métricas y drift reports.

Policy Enforcement Agent

Aplica políticas de retención, acceso y anonimización basadas en tenant y jurisdicción.

Stack tecnológico recomendado

Governance & Catalog

  • DataHub / Amundsen / OpenMetadata para data catalog
  • Great Expectations / Soda Core para data quality checks
  • SQLGlot / dbt para documentar transformaciones

ML & Policies

  • MLflow / Vertex AI Model Registry para linaje de modelos
  • WhyLogs / Evidently para drift detection
  • OPA / HashiCorp Sentinel para policies as code

Epics & Historias (ejemplos)

Epic: Data Catalog & Linaje

  • Story: Como arquitecto quiero ver el linaje completo de un dataset para asegurar trazabilidad.
  • Story: Como Oficial quiero saber quién es el owner de un modelo para contactarle ante problemas.

Epic: Data Quality & Drift

  • Story: Como SRE quiero recibir alertas si un dataset tiene más del 5% de valores nulos.
  • Story: Como científico de datos quiero recibir notificación si un modelo en producción tiene drift.
DOM 13 – 15 CaaS Praezidium — Blueprint (Dominios 13–15)

CaaS Praezidium — Blueprint (Entrega 4: Dominios 13–15)

Esta entrega cubre: Dominio 13 (Automatización & Workflows), Dominio 14 (Infraestructura & Operaciones), y Dominio 15 (Supervisory Evidence Gateway). Cada dominio incluye: ADRs, tareas, riesgos/mitigantes, criterios de aceptación, agentes/sub‑agentes, estructura de agentes, stack tecnológico recomendado, epics e historias de usuario.

Dominio 13 — Automatización & Workflows (Engine de Orquestación de Procesos)

ADR‑004 / ADR‑008 (Workflows como Código)

Objetivo: Proveer un motor de workflows declarativos y reproducibles que permita modelar procesos de cumplimiento (ej.: Onboard → Screen → Score → Escalar → SAR Draft) como código, con versionado, testing y posibilidad de ejecución híbrida (sync/async).

ADRs relevantes

  • ADR‑004 — El control plane debe soportar flujos declarativos y multi‑tenant.
  • ADR‑003 — Automatizaciones no deben reemplazar la decisión humana para decisiones legales.
  • ADR‑001 — Todo flujo debe producir evidencia rastreable y auditable.

Tareas principales

  • Definir DSL (Workflows as Code) o adoptar Temporal/Argo/State Machine con definiciones YAML/JSON versionadas.
  • Implementar librería de task primitives reutilizables (invoke_agent, call_api, wait_for_manual_approval, attach_evidence, sign_document).
  • Construir interfaz visual de authoring (drag & drop) + editor de código, con validación y testing integrado.
  • Integrar gates HiTL: manual approval steps, SLA timers, escalation policies.
  • Implementar testing: unit tests para tasks, integration tests que simulen eventos y validen side effects (logs, DB writes).
  • Versionado y rollback de workflows; canary execution y feature flags para experimentación.

Riesgos principales

  • Workflows mal definidos que provoquen bloqueos o pérdida de evidencias (por ejemplo, saltos que omiten etapas de validación).
  • Dependencias externas (APIs de terceros) que retrasen flujos y no tengan manejo de timeout adecuado.
  • Escalation storms: many concurrent manual approvals generan cuellos de botella.

Mitigantes

  • Gate patterns: time‑boxed approvals con automatic fallback (escalation to supervisor) y circuit breakers en llamadas externas.
  • Replayability: workflows deben ser re‑ejecutables desde un punto seguro (idempotency & compensating actions).
  • Rate limiting + prioritization queues para manual review tasks (high/medium/low).
  • Comprehensive observability: tracing por workflow (trace_id) y ability to inspect state at any step.

Criterios de aceptación (MVP)

  • Definición YAML de un workflow Onboard→Screen→Score→CreateCase ejecutable en entorno staging.
  • Primitive tasks implementados: call_agent, wait_manual_approval, attach_evidence, send_notification.
  • Manual approval step funcional con SLA y escalamiento automático si expira.

Agentes & Sub‑agentes

Workflow Orchestrator Agent

Ejecuta definiciones, mantiene state, retries y compensations.

Task Runner Sub‑agents

Workers especializados para tasks CPU/IO‑bound (e.g., OCR tasks, LLM calls).

Manual Review Queue Agent

Gestiona tareas humanas, asignaciones, SLAs y cola priorizada.

Compensation Agent

Ejecuta acciones compensatorias cuando hay rollback parcial.

Stack tecnológico recomendado

Orchestration

  • Temporal / Argo Workflows / Cadence (durable workflows)
  • Worker framework: Kubernetes-based autoscaling workers

Developer Tooling

  • Definitions in YAML/JSON stored in Git (GitOps) + CI pipelines for validation
  • Visual editor: custom React app or open-source (e.g., Camunda modeler style)

Epics & Historias (ejemplos)

Epic: Workflows as Code

  • Story: Como ingeniero quiero definir un workflow en YAML y lanzarlo desde CI para que sea reproducible.
  • Story: Como QA quiero simular un flujo completo con mocks para validar side effects sin tocar producción.

Epic: Human‑In‑The‑Loop

  • Story: Como analista quiero recibir tareas de revisión con prioridad alta y la información necesaria para decidir en una sola vista.
  • Story: Como manager quiero reglas de escalamiento que asignen la tarea a un suplente si no hay respuesta en X horas.

Dominio 14 — Infraestructura & Operaciones (IaC, SRE, Seguridad y Continuidad)

ADR‑004 / ADR‑001 / Security‑By‑Design

Objetivo: Definir la arquitectura cloud‑native, IaC, prácticas SRE, seguridad (zero‑trust), backup/DR y procedimientos operativos para garantizar disponibilidad, confidencialidad e integridad de un CaaS regulatorio.

ADRs relevantes

  • ADR‑004 — Multi‑tenant infra desde el inicio; plantillas IaC para despliegues dedicados.
  • ADR‑001 — Guardar evidencias con trazabilidad y protección criptográfica.

Tareas principales

  • Definir Landing Zone / Account structure (org) en el proveedor cloud elegido (o multi‑cloud blueprint).
  • Implementar IaC templates (Terraform modules) para: control plane, tenant stacks, networking (VPCs), kms, monitoring.
  • Configurar CI/CD (ArgoCD / GitHub Actions) con pipelines para infra + app; despliegues canary y rollbacks automáticos.
  • Implementar SRE playbooks: runbooks, playbooks incident response, SLO/SLA y error budgets.
  • Seguridad: Zero‑Trust network policies, WAF, secrets management, vulnerability scanning (SCA), pentests regulares.
  • Continuidad: Backup strategy, cross‑region DR, RTO/RPO targets y pruebas regulares de DR.

Riesgos principales

  • Fallo de configuración IaC que provoque exposición de datos (ej. bucket público accidental).
  • Incidentes de seguridad no detectados o respuesta lenta a brechas.
  • Costos cloud que escalan sin control por errores de autoscaling o logs retenidos indefinidamente.

Mitigantes

  • Pre‑commit & CI policy checks para IaC (tfsec, checkov) y guardrails de cuenta (organization SCPs).
  • Monitoring & detection: IDS/IPS, EDR, SIEM (centralized), and automated playbooks for common incidents.
  • Cost controls: budgets, alerts, autoscaling policies, lifecycle policies for logs and object storage.
  • Periodic DR drills and purple‑team exercises; access reviews and least privilege enforced.

Criterios de aceptación (MVP)

  • IAC modules for core infra (control plane, tenant base) deployed in at least one cloud region using CI pipeline.
  • SLOs defined for critical flows (e.g., onboarding < 2min UI latency, scoring API < 200ms at 95th percentile) and dashboards surfaced.
  • Backup/DR tested with RTO & RPO documented for core services.

Agentes & Roles operativos

SRE Agent

Automatiza runbooks, escalaciones, y mantiene SLOs; controla autoscaling y capacity planning.

Security Ops (SecOps) Agent

Gestiona detección de intrusiones, vulnerabilidades y respuesta a incidentes.

Infra Provisioning Agent

Ejecuta Terraform modules y aplica guardrails; reporta drift.

Cost & Usage Agent

Monitorea consumo por tenant y genera alertas de anomalías de coste.

Stack tecnológico recomendado

Infra & CI/CD

  • Terraform + Terragrunt (IaC) • ArgoCD / Flux (GitOps)
  • Kubernetes (EKS/GKE/AKS) + Horizontal Pod Autoscaler + Cluster Autoscaler
  • Platform tooling: Crossplane (opcional) para multi-cloud abstractions

Observability & Security

  • Prometheus + Grafana, Jaeger for tracing, ELK / OpenSearch for logs
  • SIEM: Elastic SIEM / commercial; EDR: CrowdStrike or similar
  • Secrets: HashiCorp Vault / Cloud KMS; Image scanning: Trivy/Snyk

Epics & Historias (ejemplos)

Epic: IaC & Landing Zone

  • Story: Como infra engineer quiero módulos terraform para crear un tenant aislado siguiendo las guardrails de seguridad.
  • Story: Como SRE quiero pipelines que desplieguen la app y validen SLOs automáticamente.

Epic: Security & DR

  • Story: Como CISO quiero runbooks automatizados para un incidente de data leak y playbooks de comunicación.
  • Story: Como operador quiero pruebas de DR trimestrales que validen RTO y RPO.

Dominio 15 — Supervisory Evidence Gateway (Acceso regulador por evidencia)

ADR‑001 (Formal)

Objetivo: Proveer a reguladores acceso controlado, limitado y auditable a evidencia relevante de casos (expedientes) sin otorgar acceso general a la plataforma. El Gateway implementa time‑boxed, scope‑restricted, read‑only sessions, con capacidad de export firmado y control de escopo por caso/periodo.

ADRs relevantes

  • ADR‑001 (Regulator Evidence Gateway) — Regulador accede a evidencia, no al sistema completo; sesiones deben ser auditable y revocables.
  • ADR‑005 — Tenancy federation: support for parent/child tenants with scoped evidence sharing.

Tareas críticas

  • Diseñar authorization model: roles for regulator actors, token scopes (case_read, evidence_download, metadata_only), and time limits.
  • Implementar UI/portal read‑only para reguladores con session recording (video/keystroke optional) and read receipts.
  • Implement API: request_evidence_access (case_id, justification, duration) → create scoped session token, notify tenant owner.
  • Redaction & Minimization: ability to redact PII fields on a per‑request basis, with tenant approval flows if required by policy.
  • Export signing: evidence pack exports digitally signed (hash+signature), produce JSON metadata + PDF bundle.
  • Audit trail: every regulator access event written to immutable audit log with actor, justification, TTL and items accessed.
  • Legal hold & embargo: ability for tenant to set holds and for gateway to respect legal embargoes while documenting regulatory requests.

Riesgos principales

  • Exposición excesiva de datos por tokens con scopes demasiado amplios.
  • Abuso de acceso regulador sin justificación o sin notificación al cliente (where legally required).
  • Disputes where regulator requests conflict with local privacy laws or client nondisclosure.

Mitigantes

  • Least privilege by default: fine‑grained scopes (field-level) and short TTLs (e.g., 24–72h) with mandatory justification.
  • Tenant notification + optional tenant approval workflow where law permits; maintain audit record regardless.
  • Policy engine (OPA) to evaluate cross-jurisdiction rules (e.g., UIF vs GDPR) before granting access; log decisions.
  • Redaction templates per jurisdiction and per tenant; reversible redaction audit trail (who redacted, why).

Criterios de aceptación (MVP)

  • Regulator can request access to a case and receive a scoped, time‑limited read‑only session token after automated policy evaluation.
  • Every access is logged in the immutable audit log with justification and TTL; exports are signed and include provenance metadata.
  • Redaction controls exist and can be applied prior to export; tenant is notified of access events (configurable).

Agentes & Sub‑agentes

Supervisory Gateway Agent

Entry point for regulator requests: validates, scopes and issues timeboxed tokens.

Policy Evaluation Sub‑agent

Runs OPA policies and cross‑jurisdiction checks before granting access.

Redaction Engine

Applies masking/redaction templates and records redaction provenance.

Evidence Packager & Signer

Bundles evidence, computes hashes, signs package and records metadata in audit log.

Stack tecnológico recomendado

Authorization & Policy

  • OAuth2.0 / OIDC for regulator authentication • token scopes & short TTLs
  • OPA (Rego) for policy evaluation • policies stored versioned in Git

Packaging & Auditing

  • Redaction: custom service with templating (must be deterministic & logged)
  • Digital signing: KMS + signed manifest (JSON) + Merkle root for content
  • Audit log: append-only store (see Dominio 10) with per-access hashes

Epics & Historias (ejemplos)

Epic: Regulator Access Flow

  • Story: Como regulador quiero solicitar acceso a un caso con razón y recibir acceso read‑only por 48 horas si la política lo permite.
  • Story: Como tenant admin quiero ser notificado cuando un regulador accede a uno de mis casos y ver el package firmado que se exportó.

Epic: Policy & Redaction

  • Story: Como legal quiero que OPA evalúe la solicitud de acceso cruzando reglas locales y que el sistema aplique redaction si es necesario.
  • Story: Como auditor quiero extraer el histórico de accesos regulatorios con motivos y hashes para verificaciones externas.
DOM 16 -18 CaaS Praezidium — Blueprint (Dominios 16–18)

CaaS Praezidium — Blueprint (Entrega 5: Dominios 16–18 + Cierre)

Esta entrega cubre: Dominio 16 (Sanciones Avanzadas), Dominio 17 (Fusion Engine — correlación Screening ↔ TMS), Dominio 18 (Contratos, Derecho Mercantil, Legal-Auth). También incluye: Backlog maestro de Sprints (0–6), JSONs de ejemplo para workflows y cierre del documento.

Dominio 16 — Sanciones Avanzadas & Investigación Forense

ADR‑001 / ADR‑003

Objetivo: Proporcionar herramientas para investigar y gestionar casos de sanciones complejas; incluye seguimiento de flujo de fondos, construcción de redes de propiedad/relaciones, y generación de reportes forenses para autoridades o litigios.

ADRs relevantes

  • ADR‑001 — Toda investigación debe ser reproducible, con evidencia firmada y trazabilidad completa.
  • ADR‑003 — IA asistente, pero Oficial firma decisiones.

Tareas principales

  • Implementar Graph Explorer UI: visualizar nodos (personas, cuentas, empresas) y relaciones (transferencias, ownership, PEP links).
  • Módulo de tracing: reconstrucción de cadena de transacciones, con capacidad de expandir conexiones (expand graph).
  • Forensic annotation: permitir que Oficiales anoten evidencias visuales (notes, highlights, timestamps).
  • Reporte forense: exportable PDF firmado con anotaciones + chain of custody.
  • Integración con TMS y Screening para enlazar alertas con casos investigados.

Riesgos principales

  • Construcción incorrecta del grafo por datos parciales o falsos positivos.
  • Omisión de nodos críticos o relaciones que lleven a conclusiones erróneas.
  • Compromiso de integridad evidencial por manipulación o falta de trazabilidad.

Mitigantes

  • Confidence levels en edges/nodes (por ejemplo, confidence: "high" para relaciones directas, "medium" para inferidas).
  • Historial de modificaciones del grafo y anotaciones, con firmas y timestamps.
  • Auditoría automática de inconsistencias (grafo ciclos, nodos huérfanos sospechosos).

Criterios de aceptación (MVP)

  • UI de Explorador de Grafo muestra al menos 3 nodos y sus relaciones con confidence score.
  • Anotaciones visuales pueden ser guardadas, versionadas y exportadas con firma digital.
  • Informe forense PDF generado con anotaciones y firma digital.

Agentes & Sub‑agentes

Forensic Graph Agent

Gestiona expansión del grafo, scoring de confianza y persistencia.

Annotation Sub‑agent

Registra y firma anotaciones visuales de analistas.

Trace Reconstructor

Traza flujos de dinero basado en transacciones y vínculos conocidos.

Forensic Reporter

Compone PDF firmado con anotaciones, grafo y datos forenses.

Stack tecnológico recomendado

Graph & Visualization

  • Neo4j / Amazon Neptune para almacenamiento del grafo
  • React + D3.js / Vis.js para visualización interactiva

Forensics & Signing

  • PDF generator: WeasyPrint
  • Firma digital: KMS + hash manifest

Epics & Historias (ejemplos)

Epic: Graph Explorer MVP

  • Story: Como analista quiero visualizar el grafo de relaciones de un caso y ver confidence score de cada arista.
  • Story: Como Oficial quiero hacer zoom en nodos y expandir conexiones automáticamente.

Epic: Forensic Export

  • Story: Como investigador quiero exportar mi grafo con anotaciones como PDF firmado para litigios.
  • Story: Como auditor quiero revisar el histórico de anotaciones de un caso.

Dominio 17 — Fusion Engine (Screening ↔ Transaction Monitoring ↔ Tipologías)

ADR‑001 / ADR‑006

Objetivo: Correlacionar señales entre Screening Hits, Transacciones Anómalas y Tipologías para detectar patrones multifacéticos de riesgo (ej.: transacciones altas + match en lista PEP + tipología TBML).

ADRs relevantes

  • ADR‑001 — Correlaciones deben ser explicables y rastreables.
  • ADR‑006 — Tipologías guían la interpretación de correlaciones.

Tareas principales

  • Construir Event Correlator: recibe eventos de Screening, Transacciones y Tipologías y busca coincidencias.
  • Definir scoring de correlación: combinar confidences de cada señal (ej. screening_confidence × anomaly_score × typology_match).
  • Generar alertas fusionadas: casos que involucran múltiples fuentes de evidencia.
  • Exponer UI con timeline de eventos correlacionados y sugerencias de tipología aplicable.

Riesgos principales

  • Correlaciones espurias que generen falsas alarmas (noise inflation).
  • Latencia en correlación que retrase detecciones críticas.
  • Interpretación errónea de correlaciones debido a tipologías desactualizadas.

Mitigantes

  • Thresholds configurables para correlación y scoring.
  • Event windowing para evitar correlación fuera de contexto temporal.
  • Feedback loop: analistas pueden invalidar correlaciones, lo cual mejora futuras predicciones.

Criterios de aceptación (MVP)

  • Event Correlator recibe eventos de Screening Hit, Transaction Anomaly y Typology Match y produce caso fusionado.
  • UI muestra timeline de eventos correlacionados con scores y sugerencias de tipología.

Agentes & Sub‑agentes

Fusion Orchestrator

Orquesta recepción y correlación de eventos multidominio.

Correlation Engine

Calcula correlaciones y scores combinados.

Alert Generator

Emite casos fusionados con evidencia consolidada.

Feedback Loop Agent

Recibe retroalimentación de analistas para mejorar scoring.

Stack tecnológico recomendado

Correlation & Stream Processing

  • Kafka / Confluent para streaming
  • Flink / ksqlDB para windowing y joins temporales

UI & Feedback

  • React frontend con timeline interactivo
  • PostgreSQL para registrar feedback de analistas

Epics & Historias (ejemplos)

Epic: Correlation Engine MVP

  • Story: Como analista quiero recibir alertas cuando haya coincidencia entre Screening, Transacción y Tipología.
  • Story: Como Oficial quiero ver el timeline de correlaciones en una sola pantalla con scores explicativos.

Epic: Feedback Loop

  • Story: Como investigador quiero invalidar una correlación errónea para que el sistema aprenda.
  • Story: Como ML engineer quiero usar feedback de analistas para mejorar scoring de correlación.

Dominio 18 — Contratos, Derecho Mercantil & Legal-Auth

ADR‑007 / ADR‑002

Objetivo: Integrar servicios legales en la plataforma: generación automática de contratos, términos de uso, avisos de privacidad, cláusulas de responsabilidad y SLAs. Debe cumplir con normativa mercantil local y reglamentaciones de proteccción de datos.

ADRs relevantes

  • ADR‑007 — GTM usa mensajes cuidadosos de responsabilidad legal.
  • ADR‑002 — Los documentos deben ser adaptables por jurisdicción.

Tareas principales

  • Diseñar templates de contratos: Términos de Servicio, Privacidad, SLA, Responsabilidad Limitada, Política de Retención de Datos.
  • Integrar firma electrónica: DocuSign / Docuseal / Adobe Sign con autenticación multifactor.
  • Habilitar versionado de documentos con firmas y timestamps criptográficos.
  • Adaptación jurisdiccional automática (MX, US, EU) basada en tenant settings.
  • Generador de aviso de privacidad dinámico con consent checkboxes y logs.

Riesgos principales

  • Plantillas desactualizadas que incumplan con nuevas leyes (como nuevas reformas a LFPDPPP).
  • Documentos mal adaptados a jurisdicción que generen inconformidades legales.
  • Falta de consentimiento claro o registro de aceptación de términos.

Mitigantes

  • Workflow de revisión legal: cada cambio en contrato pasa por aprobación de jurista.
  • Template engine con placeholders por jurisdicción y políticas de datos.
  • Logs de consentimiento firmados digitalmente con evidencia imborrable.

Criterios de aceptación (MVP)

  • Generación de Términos de Servicio y Política de Privacidad con firma electrónica lista para usar.
  • Adaptación automática de documentos a jurisdicción del cliente (MX o US).
  • Consentimiento de usuario grabado digitalmente con hash firmado.

Agentes & Sub‑agentes

Legal Template Engine

Maneja placeholders, versionado y adaptación por jurisdicción.

eSignature Agent

Integra firma electrónica y registra evidencias.

Compliance Publisher

Publica aviso de privacidad y registra consentimientos.

Legal Review Agent

Workflow de aprobación legal para cambios en documentos.

Stack tecnológico recomendado

Templates & Signing

  • Template Engine: Jinja2 / Liquid / custom
  • eSignature: DocuSign / Docuseal API
  • Storage: S3 bucket con versionado

Compliance & Audit

  • PDF Generator: WeasyPrint / Puppeteer
  • Immutable logs: append-only DB (TimescaleDB/Chronicle)

Epics & Historias (ejemplos)

Epic: Document Generation

  • Story: Como cliente quiero firmar los Términos de Servicio al crear mi cuenta con un click.
  • Story: Como Oficial quiero que los documentos se adapten automáticamente según mi jurisdicción.

Epic: Consentimiento Legal

  • Story: Como jurista quiero que el sistema grabe consentimientos con firma digital y timestamps.
  • Story: Como auditor quiero consultar el registro completo de consentimientos de un cliente.

Backlog Maestro de Sprints (0–6)

  • Sprint 0: Discovery, Blueprint, Data Governance, Ingesta de Tipologías (CSV → KB)
  • Sprint 1: Infra Cloud, Data Lake/Pipeline, IAM, Logging/Auditoría
  • Sprint 2: AI Orchestration (Master + Specialized Agents), RAG, Routing
  • Sprint 3: Aplicaciones Core (Onboarding, Screening, Monitoring, Risk Matrices)
  • Sprint 4: Reporting Engine, Feed Aggregator, Correlación Cross-Función
  • Sprint 5: LMS, Calendar/Video, Query Hub, Integraciones de Terceros
  • Sprint 6: Endurecimiento, Testing de Cumplimiento, CI/CD, Observabilidad
📊 Sprint 0 — JSON Ejemplo: Tipología KB Entry
{
  "tipologia_id": "tbml_001",
  "tipologia": "TBML + manipulación de precios agrícolas + empresas fachada",
  "ambito": "México / LATAM",
  "tipo_registro": "caso_analizado",
  "fase_lavado": "Colocación → Integración (ciclo corto)",
  "delito_precedente": "Narcotráfico / extorsión",
  "sector_vulnerable": "Agroindustrial",
  "producto_financiero": "Efectivo / SPEI",
  "señal_de_alerta_clave": "Margen reventa >200%",
  "norma_aplicable": "Art. 400 Bis CPF",
  "herramienta_deteccion": "Feedzai / ComplyAdvantage"
}
🔁 Sprint 1 — JSON Ejemplo: Event Schema (Audit Log Entry)
{
  "event_id": "ev_9f8e7d6c5b",
  "timestamp": "2025-04-05T14:30:22Z",
  "tenant_id": "tn_abc123",
  "actor": {
    "type": "human",
    "id": "usr_xyz987"
  },
  "action": "create_case",
  "resource_type": "case",
  "resource_id": "case_456def",
  "metadata": {
    "payload_hash": "sha3:abcd1234...",
    "case_type": "screening_hit"
  }
}
🧬 Sprint 2 — JSON Ejemplo: Matched Typology (Inferencia)
{
  "matched_typology": {
    "tipologia_id": "tbml_001",
    "confidence": 0.87,
    "inferred_phase": "layering",
    "strategy_used": "abduction",
    "cited_sources": [
      {
        "titulo": "Estudio de Tipologías en Materia de Lavado de Activos Basado en el Comercio",
        "organizacion": "OAS / GELAVEX",
        "anio": 2019
      }
    ],
    "matched_signals": [
      {
        "signal": "margen reventa >200%",
        "detected_in": "transaction_monitoring"
      }
    ]
  }
}
🧠 Sprint 2 — JSON Ejemplo: Reasoning Strategy Request
{
  "inputs": {
    "signals": [
      {
        "signal": "cliente nuevo con depósito > $100k",
        "source": "transaction_monitoring"
      },
      {
        "signal": "match PEP con score > 0.95",
        "source": "screening_engine"
      }
    ],
    "strategy": "abduction"
  },
  "output": {
    "hypotheses": [
      {
        "description": "Cliente nuevo oculta origen de fondos usando PEP como pantalla.",
        "confidence": 0.91,
        "typology_match": "smurfing + PEP"
      }
    ]
  }
}
🛠️ Sprint 3 — JSON Ejemplo: Risk Score
{
  "score_id": "sc_123abc",
  "client_id": "cli_def456",
  "value": 0.78,
  "category": "High Risk",
  "drivers": [
    {
      "factor": "PEP Match",
      "weight": 0.3,
      "impact": "increase"
    },
    {
      "factor": "Transacción Anómala",
      "weight": 0.25,
      "impact": "increase"
    }
  ],
  "generated_at": "2025-04-05T15:12:00Z"
}
📜 Sprint 3 — JSON Ejemplo: SAR Draft Payload
{
  "sar_id": "sar_ghi789",
  "case_id": "case_456def",
  "client_info": {
    "name": "Juan Pérez",
    "rfc": "PEPJ800101XXX"
  },
  "narrative": "Cliente presenta transacciones >$100k sin perfil declarado. Match en lista PEP confirmado con score 0.95.",
  "matched_typologies": [
    {
      "tipologia": "smurfing + PEP",
      "confidence": 0.91
    }
  ],
  "evidences_attached": [
    {
      "type": "transaction_log",
      "hash": "sha3:def456..."
    },
    {
      "type": "screening_match_report",
      "hash": "sha3:ghi789..."
    }
  ]
}
🔗 Sprint 4 — JSON Ejemplo: Fusion Alert
{
  "fusion_case_id": "fc_987zyx",
  "correlated_events": [
    {
      "event_type": "screening_hit",
      "event_id": "sh_111aaa",
      "timestamp": "2025-04-05T10:00:00Z"
    },
    {
      "event_type": "transaction_anomaly",
      "event_id": "ta_222bbb",
      "timestamp": "2025-04-05T10:05:00Z"
    }
  ],
  "correlation_score": 0.93,
  "suggested_typology": "smurfing + PEP",
  "confidence": 0.89
}
📊 Sprint 4 — JSON Ejemplo: Feedback Loop Entry
{
  "feedback_id": "fb_333ccc",
  "fusion_case_id": "fc_987zyx",
  "analyst": "usr_xyz987",
  "feedback_type": "invalidate_correlation",
  "reason": "Coincidencia temporal falsa",
  "timestamp": "2025-04-05T16:45:00Z"
}
🧩 Sprint 5 — JSON Ejemplo: Tenant Configuration
{
  "tenant_id": "tn_abc123",
  "settings": {
    "jurisdiction": "MX",
    "features_enabled": [
      "onboarding",
      "monitoring",
      "reporting"
    ],
    "policies": {
      "retention_days": 3650,
      "pii_minimization": true
    }
  },
  "version": "1.2.0",
  "created_by": "admin_user",
  "applied_at": "2025-04-05T09:00:00Z"
}
🔁 Sprint 5 — JSON Ejemplo: LMS Course Completion
{
  "course_completion_id": "lc_444ddd",
  "user_id": "usr_xyz987",
  "course_id": "c_pldft_intro",
  "completed_at": "2025-04-05T17:30:00Z",
  "score": 92,
  "certificate_hash": "sha3:jkl012...",
  "tenant_id": "tn_abc123"
}
🔒 Sprint 6 — JSON Ejemplo: Security Incident Report
{
  "incident_id": "inc_555eee",
  "type": "unauthorized_access_attempt",
  "severity": "high",
  "detected_at": "2025-04-05T18:00:00Z",
  "details": {
    "source_ip": "203.0.113.5",
    "user_agent": "curl/7.68.0",
    "attempted_action": "access_case_file"
  },
  "response_taken": [
    "blocked_ip",
    "notified_secops_team"
  ],
  "closed_at": "2025-04-05T18:10:00Z"
}
🧮 Sprint 6 — JSON Ejemplo: Resource Utilization Metrics
{
  "metric_id": "rm_666fff",
  "tenant_id": "tn_abc123",
  "service": "risk_scoring_api",
  "metrics": {
    "requests_per_minute": 120,
    "avg_response_time_ms": 150,
    "error_rate_percent": 0.5
  },
  "recorded_at": "2025-04-05T19:00:00Z"
}
🔁 JSON Ejemplo: Workflow Definition — Onboarding + Screening
---
specVersion: '1.0'
id: onboard-screen-workflow
version: '1.0'
name: "Onboard + Screen User"
start: StartOnboarding
states:
  - name: StartOnboarding
    type: operation
    actions:
      - functionRef: "OnboardingAgent.invoke"
        arguments:
          userId: "${ .userId }"
    transition: WaitForApproval
  - name: WaitForApproval
    type: sleep
    duration: PT5S
    transition: RunScreening
  - name: RunScreening
    type: operation
    actions:
      - functionRef: "ScreeningAgent.match"
        arguments:
          userId: "${ .userId }"
    transition: GenerateReport
  - name: GenerateReport
    type: operation
    actions:
      - functionRef: "ReportingAgent.draft"
        arguments:
          userId: "$${ .userId }"
          findings: "$${ .findings }"
    end: true
🔁 JSON Ejemplo: Workflow Definition — Risk Scoring
---
id: risk-scoring-flow
version: '1.0'
name: "Calculate Risk Score"
start: CollectFeatures
states:
  - name: CollectFeatures
    type: operation
    actions:
      - functionRef: "FeatureStore.getFeatures"
        arguments:
          clientId: "${ .clientId }"
    transition: ComputeScore
  - name: ComputeScore
    type: operation
    actions:
      - functionRef: "RiskScorer.compute"
        arguments:
          features: "${ .features }"
    transition: NotifyIfHighRisk
  - name: NotifyIfHighRisk
    type: switch
    dataConditions:
      - condition: "${ .score.value > 0.8 }"
        transition: SendAlert
    default:
      end: true
  - name: SendAlert
    type: operation
    actions:
      - functionRef: "Notifier.send"
        arguments:
          message: "High risk client: ${ .clientId }"
    end: true
🔁 JSON Ejemplo: Workflow Definition — Typology Match
---
id: typology-matcher-flow
version: '1.0'
name: "Match Typology Hypothesis"
start: ReceiveAlertSignal
states:
  - name: ReceiveAlertSignal
    type: event
    eventRefs:
      - AlertReceived
    transition: RunInference
  - name: RunInference
    type: operation
    actions:
      - functionRef: "TypologyEngine.infer"
        arguments:
          signals: "${ .signals }"
    transition: SaveHypothesis
  - name: SaveHypothesis
    type: operation
    actions:
      - functionRef: "CaseManager.save"
        arguments:
          hypothesis: "${ .hypothesis }"
    end: true
🔁 JSON Ejemplo: Workflow Definition — Fusion Correlation
---
id: fusion-engine-flow
version: '1.0'
name: "Fuse Signals Across Engines"
start: ListenForEvents
states:
  - name: ListenForEvents
    type: event
    eventRefs:
      - ScreeningHit
      - TransactionAnomaly
    transition: CorrelateSignals
  - name: CorrelateSignals
    type: operation
    actions:
      - functionRef: "FusionEngine.correlate"
        arguments:
          events: "${ .events }"
    transition: EmitFusionAlert
  - name: EmitFusionAlert
    type: operation
    actions:
      - functionRef: "AlertSystem.emit"
        arguments:
          fusedAlert: "${ .fusionResult }"
    end: true
🔁 JSON Ejemplo: Workflow Definition — Regulator Evidence Request
---
id: regulator-access-flow
version: '1.0'
name: "Handle Regulator Access Request"
start: ValidateRequest
states:
  - name: ValidateRequest
    type: operation
    actions:
      - functionRef: "PolicyEngine.validate"
        arguments:
          requestId: "${ .requestId }"
    transition: GrantScopedAccess
  - name: GrantScopedAccess
    type: operation
    actions:
      - functionRef: "SupervisoryGateway.grant"
        arguments:
          token_ttl: "48h"
          scope: "case_read_only"
    transition: NotifyTenantOwner
  - name: NotifyTenantOwner
    type: operation
    actions:
      - functionRef: "Notifier.send"
        arguments:
          message: "Regulator accessed case."
    end: true
🔁 JSON Ejemplo: Workflow Definition — Legal Consent Collection
---
id: consent-collection-flow
version: '1.0'
name: "Collect Legal Consent"
start: ShowConsentModal
states:
  - name: ShowConsentModal
    type: operation
    actions:
      - functionRef: "UIClient.showConsent"
        arguments:
          tenantId: "${ .tenantId }"
    transition: WaitForAcceptance
  - name: WaitForAcceptance
    type: event
    eventRefs:
      - ConsentAccepted
    transition: RecordSignedConsent
  - name: RecordSignedConsent
    type: operation
    actions:
      - functionRef: "LegalAuthAgent.record"
        arguments:
          signature: "${ .signature }"
          consentType: "privacy_policy"
    end: true
DOM 19 – 20 CaaS Praezidium — Blueprint (Dominios 19–20: Web3 & Blockchain Infra)

CaaS Praezidium — Dominios 19 & 20

Dos nuevos dominios: 19 (Web 3.0, Wallets y Criptografía — regulación y nuevas taxonomías) y 20 (Infraestructura de conexión a blockchains, protocolos y tokens). Para cada dominio incluyo: ADRs, tareas, riesgos principales, mitigantes, criterios de aceptación, agentes/sub‑agentes y stack recomendado, además de épicas e historias. Al final: 18 tarjetas desplegables con JSON de definiciones de workflow aplicadas a Web3/blockchain operativa y compliance.

Dominio 19 — Web 3.0, Wallets & Criptografía: regulación y nuevas taxonomías

ADR‑008 (Web3 Taxonomy) • ADR‑003 (Human-in-loop)

Propósito

Definir la capa de producto que gestiona activos cripto y wallets, clasifica tokens/protocolos, soporta firmas on‑device, y aplica taxonomías regulatorias (e.g., VASP mapping, custodian vs non‑custodian, token risk categories). Todo con trazabilidad y evidencia para auditoría/reguladores.

ADRs relevantes

  • ADR‑008 (Web3 Taxonomy) — Mantener un catálogo versionado de taxonomías de activos: token types (stablecoin, utility, governance), protocol risk labels (bridge, mixer, DEX), and custody models.
  • ADR‑003 — Operaciones sensibles (e.g., bloqueo de wallet, decisión de hold) requieren aprobación humana.
  • ADR‑001 — Todas las interacciones deben generar evidencia hashable para export y auditoría.

Tareas principales

  • Diseño del registro de wallets y sus modelos: custodial, non‑custodial (self‑custody), hosted wallets, hardware integration (WebAuthn / Ledger / Trezor).
  • Implementar flows de wallet onboarding con signature‑based KYC consent (signed consent messages), device attestation y nonce challenges.
  • Crear y versionar la Taxonomía de Activos (JSON schema) y políticas de clasificación automática + manual override.
  • Desarrollar token labeling pipeline: ingest token metadata (ERC/ERC‑20/721/1155 / SPL / BEP), onchain heuristics (liquidity, issuer, audits), 3rd party signals (CertiK, DeFiLlama, Chainalysis labels).
  • Soporte para signatures & cryptographic proofs: signed evidence, merkle proofs for onchain snapshots, and time‑stamped attestations.
  • Integración de sanciones/blacklists con onchain address resolution and offchain entities mapping (wallet ↔ entity).

Riesgos principales

  • Falsos positivos/negativos en clasificación token (e.g., a rug‑token marked as low risk).
  • Compromiso de claves privadas por integración defectuosa con hardware wallets o hot wallets.
  • Ambigüedad legal en la clasificación de tokens y responsabilidades entre custodial vs non‑custodial.

Mitigantes

  • Human‑review gates para reclasificación y decisiones de bloqueo; mantener trazabilidad de quién aprobó cambios.
  • Key‑management best practices: never store raw private keys server‑side for non‑custodial flows; use hardware signers and WebAuthn where possible.
  • Policy engine con jurisdicción-aware rules (e.g., Mexico: reglas UIF/SHCP, US: FinCEN treatise) para aplicar mitigantes legales y escalado.
  • Confidence scores + provenance for token labels; require manual override if confidence < threshold.

Criterios de aceptación (MVP)

  • Taxonomía de tokens publicada v1 (JSON) con al menos 6 categories y API de consulta/versionado.
  • Wallet onboarding flow que capture key‑attestation, signed consent y cree un registro KYC vinculado a wallet address.
  • Pipeline de token labeling que enriquece metadata onchain + offchain y entrega label + confidence.

Agentes & Sub‑agentes (estructura)

Wallet Management Agent

Registra wallets, mantiene vinculación KYC, gestiona custody mode y device attestation.

Crypto Taxonomy Agent

Mantiene catálogo de token/protocol taxonomies, versionado y reglas de clasificación.

Signature & Proof Sub‑agent

Genera/valida firmas, merkle proofs, timestamped attestations y evidence hashes.

Sanctions & Onchain Resolver

Resuelve direcciones a entidades, enriquece con listas sancionadas y watchlists onchain.

Stack tecnológico recomendado

Wallet & Signatures

  • Web3 libraries: ethers.js / web3.js / webauthn integration
  • Hardware wallet integration: Ledger / Trezor SDKs, WebHID/WebUSB
  • Attestation: FIDO2 / WebAuthn

Taxonomy & Metadata

  • Metadata store: PostgreSQL + JSONB for token schema; versioning in Git (GitOps)
  • Enrichment: use Chain APIs (Infura/Alchemy), token lists (Tokenlists.org), Chainalysis/ELLiptic signals

Epics & Historias (ejemplos)

Epic: Wallet Onboarding & Proofs

  • Story: Como usuario quiero registrar mi wallet firmando un mensaje para probar la propiedad sin subir mi clave.
  • Story: Como compliance officer quiero ver el device attestation y ver el risk label de la wallet.

Epic: Token Taxonomy & Labeling

  • Story: Como analista quiero ver el label de un token, su evidencia y score de confianza.
  • Story: Como product owner quiero publicar una nueva versión de la taxonomía y notificar tenants.

Dominio 20 — Infraestructura de Conexión a Blockchains, Protocolos y Tokens

ADR‑009 (Secure Onchain Connectors) • ADR‑008

Propósito

Proveer la capa técnica y operativa para ingest, normalización y verificación de datos on‑chain y off‑chain: full‑node/archival access, RPC pooling, webhook & stream processors, indexers, token adapters, bridge/watchers y manejo de reorganizaciones (reorgs).

ADRs relevantes

  • ADR‑009 (Secure Onchain Connectors) — Conectores a chains deben ser configurables, aislados por tenant y soportar failover y reconciliación de datos.
  • ADR‑008 — Los metadatos de tokens deben mapearse a la taxonomía formal.

Tareas principales

  • Diseñar arquitectura híbrida: node‑based ingestion (archival/full nodes) + 3rd party RPC/Indexer fallbacks (Alchemy, Infura, QuickNode, TheGraph).
  • Implementar stream layer: Kafka topics por chain + domain events (tx, internal tx, logs) + indexers for token transfers and contract events.
  • Crear adapters: ERC‑20/721/1155, SPL, native token parsers, bridge event parsers.
  • Reorg handling & finality: design para detectar reorgs, revert/compensate events and re‑compute derived state deterministically.
  • Rate limiting, caching and pagination for on‑demand lookups (balance checks, tx lookups).
  • Key rotation & secrets: protect RPC keys, node credentials, and signer access; segregate per tenant when dedicated node requested.

Riesgos principales

  • Discrepancias por reorgs o forks que invaliden evidencia previamente almacenada.
  • Dependencia excesiva en proveedores RPC que cause sesgo o pérdida de data (rate limits, downtime).
  • Exposición de RPC/secrets que permita manipulación de datos o uso indebido de recursos.

Mitigantes

  • Multi‑provider strategy: primary full node (self‑hosted or hosted archive) + secondary RPC fallback + indexer verification (TheGraph/Custom indexer).
  • Deterministic ingestion with event receipts + merkle proofs where available; immutable snapshotting and hash chaining.
  • Secure storage for secrets (Vault) and per‑tenant key scoping; rotate keys regularly and audit use.
  • Reconciliation jobs that detect divergence and repair derived store state using canonical chain tips.

Criterios de aceptación (MVP)

  • Pipeline ingest de al menos una chain (e.g., Ethereum) con events parsed (ERC‑20 transfers, contract events) y publicados a Kafka.
  • Mechanism to detect & handle reorgs (rollback + replay) for ingested ranges.
  • Adapters for ERC‑20 and ERC‑721 tokens producing normalized token transfer records.

Agentes & Sub‑agentes (estructura)

Chain Connector Agent

Mantiene conexiones a nodes/RPC, failover, and health checks; immutable receipts per block.

Indexer Sub‑agent

Indexa logs & events, normaliza transfer objects and emits domain events to stream platform.

Reorg Handler

Detecta reorganizaciones, marca ranges no final y orquesta compensations + replays.

Token Adapter Agent

Parses contract ABI, enriches with token metadata and maps to taxonomy via Crypto Taxonomy Agent.

Stack tecnológico recomendado

Nodes & Indexing

  • Self‑hosted geth / Erigon (archive for forensic needs) or managed nodes via Alchemy/Infura/QuickNode
  • Indexer framework: custom sidecar (rust/go) or open-source like Blockscout/TheGraph for subgraphs

Streaming & Storage

  • Kafka for event bus; Flink/ksqlDB for stream transforms
  • Normalized store: ClickHouse / PostgreSQL + materialized views for analytics
  • Immutable snapshots: object storage (S3) with manifest and hash chaining

Epics & Historias (ejemplos)

Epic: Reliable Chain Ingest

  • Story: Como infra engineer quiero un pipeline que ingeste bloques y emita transfer events a Kafka con receipts.
  • Story: Como SRE quiero alertas cuando la latencia entre head tip y ingest > threshold.

Epic: Reorg & Finality Handling

  • Story: Como data engineer quiero detectar reorgs y re‑reproducir derived state sin pérdida de consistencia.
  • Story: Como analyst quiero que el sistema marque transacciones no‑finales hasta confirmación N bloques.

18 Tarjetas: Workflows (JSON/YAML) para Web3 & Blockchain Compliance

Ejemplos de definiciones de workflow (YAML/JSON) listos para usar/editar en el motor de workflows.

1) Wallet Onboarding (signed consent)
{
  "id": "wf_wallet_onboard_v1",
  "name": "Wallet Onboarding (Signed Consent)",
  "start": "RequestSignature",
  "states": [
    {"name":"RequestSignature","type":"operation","action":"WalletAgent.request_signature","transition":"VerifySignature"},
    {"name":"VerifySignature","type":"operation","action":"WalletAgent.verify_signature","transition":"KYCEnrich"},
    {"name":"KYCEnrich","type":"operation","action":"KYCEngine.enrich_from_registry","transition":"CreateWalletRecord"},
    {"name":"CreateWalletRecord","type":"operation","action":"WalletManager.create_record","end":true}
  ]
}
2) Wallet Key Attestation (hardware)
{
  "id": "wf_key_attestation_v1",
  "name": "Wallet Key Attestation (Hardware)",
  "start": "BeginAttestation",
  "states": [
    {"name":"BeginAttestation","type":"operation","action":"AttestationAgent.challenge_device","transition":"VerifyAttestation"},
    {"name":"VerifyAttestation","type":"operation","action":"AttestationAgent.verify","transition":"SaveAttestation"},
    {"name":"SaveAttestation","type":"operation","action":"WalletManager.save_attestation","end":true}
  ]
}
3) Token Labeling Pipeline
{
  "id": "wf_token_labeling",
  "name": "Token Labeling Pipeline",
  "start": "IngestToken",
  "states": [
    {"name":"IngestToken","type":"operation","action":"ChainAdapter.fetch_token_metadata","transition":"RunHeuristics"},
    {"name":"RunHeuristics","type":"operation","action":"TaxonomyAgent.score_token","transition":"ExternalEnrichment"},
    {"name":"ExternalEnrichment","type":"operation","action":"Enrichment.fetch_third_party","transition":"FinalizeLabel"},
    {"name":"FinalizeLabel","type":"operation","action":"TaxonomyAgent.publish_label","end":true}
  ]
}
4) Onchain Transaction Ingest & Normalize
{
  "id": "wf_tx_ingest_normalize",
  "name": "Onchain TX Ingest & Normalize",
  "start": "BlockArrival",
  "states": [
    {"name":"BlockArrival","type":"event","event":"BlockMined","transition":"ParseBlock"},
    {"name":"ParseBlock","type":"operation","action":"Indexer.parse_block","transition":"EmitTransfers"},
    {"name":"EmitTransfers","type":"operation","action":"Indexer.emit_transfer_events","end":true}
  ]
}
5) Reorg Detection & Reconciliation
{
  "id": "wf_reorg_handler",
  "name": "Reorg Detection & Reconciliation",
  "start": "DetectTipChange",
  "states": [
    {"name":"DetectTipChange","type":"operation","action":"ChainConnector.check_tip","transition":"IsReorg"},
    {"name":"IsReorg","type":"switch","conditions":[{"cond":"${.is_reorg}","transition":"RollbackRange"}],"default":{"end":true}},
    {"name":"RollbackRange","type":"operation","action":"ReorgHandler.rollback_and_replay","end":true}
  ]
}
6) Bridge/Bridge-Token Watcher
{
  "id": "wf_bridge_watcher",
  "name": "Bridge Watcher",
  "start": "EventBridgeLock",
  "states": [
    {"name":"EventBridgeLock","type":"event","event":"BridgeLock","transition":"EnrichBridgeEvent"},
    {"name":"EnrichBridgeEvent","type":"operation","action":"Enricher.enrich_bridge","transition":"ScoreBridgeRisk"},
    {"name":"ScoreBridgeRisk","type":"operation","action":"RiskEngine.score_bridge","transition":"EmitAlert"},
    {"name":"EmitAlert","type":"operation","action":"AlertSystem.emit","end":true}
  ]
}
7) Mixer/Privacy Protocol Detection
{
  "id": "wf_mixer_detection",
  "name": "Mixer Detection",
  "start": "ReceiveTxPattern",
  "states": [
    {"name":"ReceiveTxPattern","type":"operation","action":"Analytics.detect_mixer_pattern","transition":"Score"},
    {"name":"Score","type":"operation","action":"RiskEngine.compute_mixer_score","transition":"EscalateIfHigh"},
    {"name":"EscalateIfHigh","type":"switch","conditions":[{"cond":"${.score>0.8}","transition":"CreateCase"}],"default":{"end":true}},
    {"name":"CreateCase","type":"operation","action":"CaseManager.create","end":true}
  ]
}
8) NFT Laundering Heuristics
{
  "id": "wf_nft_laundering",
  "name": "NFT Laundering Heuristics",
  "start": "NFTTransfer",
  "states": [
    {"name":"NFTTransfer","type":"event","event":"NFTTransferEvent","transition":"EnrichNFT"},
    {"name":"EnrichNFT","type":"operation","action":"NFTAgent.fetch_provenance","transition":"ScoreNFT"},
    {"name":"ScoreNFT","type":"operation","action":"RiskEngine.score_nft","transition":"EmitAlertIfHigh"},
    {"name":"EmitAlertIfHigh","type":"switch","conditions":[{"cond":"${.score>0.7}","transition":"CreateInvestigation"}],"default":{"end":true}},
    {"name":"CreateInvestigation","type":"operation","action":"CaseManager.create","end":true}
  ]
}
9) Watchlist Address Update & Propagation
{
  "id": "wf_watchlist_propagation",
  "name": "Watchlist Update & Propagation",
  "start": "WatchlistChange",
  "states": [
    {"name":"WatchlistChange","type":"operation","action":"WatchlistService.update","transition":"Propagate"},
    {"name":"Propagate","type":"operation","action":"Notifier.propagate_to_indexers","end":true}
  ]
}
10) Onchain → Offchain Entity Resolution
{
  "id": "wf_addr_resolution",
  "name": "Address to Entity Resolution",
  "start": "NewAddress",
  "states": [
    {"name":"NewAddress","type":"operation","action":"Resolver.lookup","transition":"Enrich"},
    {"name":"Enrich","type":"operation","action":"Enricher.add_offchain_links","end":true}
  ]
}
11) Sanctions Address Hit Flow (onchain)
{
  "id": "wf_sanctions_onchain_hit",
  "name": "Sanctions Address Hit",
  "start": "AddressMatched",
  "states": [
    {"name":"AddressMatched","type":"operation","action":"SanctionsEngine.match_address","transition":"CreateAlert"},
    {"name":"CreateAlert","type":"operation","action":"AlertSystem.create","transition":"NotifyTenant"},
    {"name":"NotifyTenant","type":"operation","action":"Notifier.send_tenant_alert","end":true}
  ]
}
12) Chain Snapshot & Merkle Proof Export
{
  "id": "wf_chain_snapshot",
  "name": "Chain Snapshot & Merkle Proof",
  "start": "SnapshotTrigger",
  "states": [
    {"name":"SnapshotTrigger","type":"operation","action":"SnapshotService.create_block_snapshot","transition":"BuildMerkle"},
    {"name":"BuildMerkle","type":"operation","action":"ProofService.build_merkle","transition":"SignManifest"},
    {"name":"SignManifest","type":"operation","action":"SignatureService.sign","end":true}
  ]
}
13) Cross‑Chain Correlation (bridge-linked events)
{
  "id": "wf_cross_chain_correlation",
  "name": "Cross‑Chain Correlation",
  "start": "BridgeEvent",
  "states": [
    {"name":"BridgeEvent","type":"event","event":"BridgeEventDetected","transition":"LinkEvents"},
    {"name":"LinkEvents","type":"operation","action":"FusionEngine.link_cross_chain","transition":"Score"},
    {"name":"Score","type":"operation","action":"RiskEngine.score_cross_chain","end":true}
  ]
}
14) Token Upgrade / Contract Migration Watch
{
  "id": "wf_contract_migration_watch",
  "name": "Contract Migration Watch",
  "start": "ContractChange",
  "states": [
    {"name":"ContractChange","type":"operation","action":"ContractWatcher.detect_upgrade","transition":"Enrich"},
    {"name":"Enrich","type":"operation","action":"Enricher.fetch_audit_reports","transition":"ScoreUpgrade"},
    {"name":"ScoreUpgrade","type":"operation","action":"RiskEngine.score_contract_change","end":true}
  ]
}
15) Token Blacklist Enforcement for Custodial Tenants
{
  "id": "wf_token_blacklist_enforce",
  "name": "Token Blacklist Enforcement",
  "start": "BlacklistUpdate",
  "states": [
    {"name":"BlacklistUpdate","type":"operation","action":"PolicyEngine.update_blacklist","transition":"ApplyToCustodial"},
    {"name":"ApplyToCustodial","type":"operation","action":"CustodyManager.quarantine_tokens","end":true}
  ]
}
16) Smart Contract Risk Scoring
{
  "id": "wf_contract_risk_scoring",
  "name": "Smart Contract Risk Scoring",
  "start": "ContractDetected",
  "states": [
    {"name":"ContractDetected","type":"operation","action":"ContractAnalyzer.analyze","transition":"Score"},
    {"name":"Score","type":"operation","action":"RiskEngine.compute_contract_score","end":true}
  ]
}
17) Regulator Evidence Request (onchain snapshot)
{
  "id": "wf_regulator_onchain_evidence",
  "name": "Regulator Evidence Request — Onchain",
  "start": "RegRequest",
  "states": [
    {"name":"RegRequest","type":"operation","action":"PolicyEngine.validate_reg_request","transition":"CreateSnapshot"},
    {"name":"CreateSnapshot","type":"operation","action":"SnapshotService.create_range_snapshot","transition":"SignAndPackage"},
    {"name":"SignAndPackage","type":"operation","action":"EvidencePackager.sign_and_package","end":true}
  ]
}
18) Feedback Loop: Analyst Invalidates Onchain Correlation
{
  "id": "wf_analyst_feedback_onchain",
  "name": "Analyst Feedback — Onchain Correlation",
  "start": "AnalystFeedback",
  "states": [
    {"name":"AnalystFeedback","type":"operation","action":"FeedbackAgent.record","transition":"RetrainModel"},
    {"name":"RetrainModel","type":"operation","action":"MLTrainer.queue_retrain","end":true}
  ]
}
Próximo paso sugerido: validar si necesitaremos despliegues dedicados de nodos (archive/full) por cliente — esto impactará significativamente costos y la arquitectura de Tenant Factory. ¿Deseas que prepare una matriz de coste (CAPEX/OPEX) y opciones (self‑hosted vs managed vs hybrid) para Ethereum + BSC + Solana como anexo?

Páginas: 1 2 3 4 5 6