Agent Control Protocol (ACP)

Qué es ACP

Agent Control Protocol (ACP) proporciona gobernanza verificable para agentes autónomos. Define quién autorizó a un agente, qué ejecutó y quién es responsable del resultado a través de sistemas e instituciones.

ACP permite:

• Verificación de autoridad: Probar criptográficamente quién autorizó las acciones de un agente.
• Trazabilidad de ejecución: Mantener un registro verificable de cada operación.
• Responsabilidad institucional: Mapear inequívocamente los resultados a la institución o individuo responsable.

Por qué existe ACP

Los agentes autónomos interactúan cada vez más con sistemas reales como APIs, infraestructura empresarial, sistemas financieros y otros agentes. Cuando los agentes operan entre organizaciones, surgen varias preguntas críticas de gobernanza:

La mayoría de los sistemas actuales no pueden responder a estas preguntas de manera confiable. ACP introduce la infraestructura para responderlas definitivamente.

Cómo funciona ACP

ACP trata las interacciones de los agentes como operaciones gobernables. Cada interacción debe pasar con éxito a través de una secuencia estricta para garantizar que sea rastreable, auditable y atribuible.

Para aprender más sobre cómo ACP estructura estas interacciones, explora la Arquitectura de ACP o lee sobre nuestro Modelo de Gobernanza.

Ejemplo de Solicitud ACP

Toda acción gobernable comienza con una solicitud codificada que lleva todas las pruebas criptográficas necesarias.

{
  "agent_id": "did:acp:agent-123",
  "capability": "payments.transfer",
  "delegation_chain": [
    "org-root",
    "finance-department"
  ],
  "risk_score": 0.18,
  "timestamp": "2026-03-12T14:32:10Z",
  "signature": "0xabc123..."
}

En esta solicitud de ejecución, el agente presenta un agent_id globalmente único y solicita ejecutar la capacidad payments.transfer. Trae una cadena de delegación delegation_chain que se remonta a una raíz institucional autorizada, un puntaje de riesgo evaluado risk_score, y una firma criptográfica signature que vincula la solicitud a su raíz.

Implementación de Referencia

ACP incluye una implementación de referencia en Go de calidad de producción — no pseudocódigo. 23 paquetes, 5 niveles de conformidad, 138 vectores de prueba y el runner de conformidad ACR-1.0: validá cualquier implementación contra el contrato de ejecución completo de ACP-RISK-3.0, con criptografía real y cadenas de hash reales.

Performance

ACP es compute-cheap but state-sensitive: la evaluación de decisiones incurre en overhead mínimo, mientras que el throughput está acotado por el state backend — no por la lógica del protocolo.

La abstracción LedgerQuerier formaliza este límite — reemplazá el state backend (memoria → Redis → Postgres) sin tocar la semántica del protocolo.

Flujo de Verificación

ACP aplica el invariante de gobernanza a través de la ejecución verificable en tiempo de ejecución. El siguiente código demuestra las comprobaciones del invariante antes de conceder cualquier acceso a herramientas.

def handle_acp_request(request):
    # Enforce the Constitutional Invariant
    if not compute_signature(request) == request.signature:
        raise AuthenticationError("InvalidIdentity")
        
    if not capability_registry.has_permission(request.agent_id, request.capability):
        raise AuthorizationError("InvalidCapability")
        
    if not verify_chain(request.delegation_chain, "org-root"):
        raise DelegationError("InvalidDelegationChain")
        
    if request.risk_score > policy.max_acceptable_risk("payments.transfer"):
        raise PolicyViolationError("UnacceptableRisk")
        
    # All governance checks passed. Deterministic execution proceeds.
    return execute_capability(request)