En este tutorial, creamos un sistema de gobierno de IA de nivel empresarial utilizando OpenClaw y Python. Comenzamos configurando el tiempo de ejecución de OpenClaw y lanzando OpenClaw Gateway para que nuestro entorno Python pueda interactuar con un agente real a través de la API de OpenClaw. Luego diseñamos una capa de gobernanza que clasifica las solicitudes según el riesgo, aplica políticas de aprobación y enruta tareas seguras al agente OpenClaw para su ejecución. Al combinar las capacidades del agente de OpenClaw con controles de políticas, demostramos cómo las organizaciones pueden implementar de manera segura sistemas autónomos de IA mientras mantienen la visibilidad, la trazabilidad y la supervisión operativa.
Preparamos el entorno necesario para ejecutar el sistema de gobernanza basado en OpenClaw. Instalamos Node.js, OpenClaw CLI y las bibliotecas de Python necesarias para que nuestro portátil pueda interactuar con OpenClaw Gateway y las herramientas de soporte. También recopilamos de forma segura la clave API de OpenAI a través de un mensaje de terminal oculto e inicializamos los directorios y variables necesarios para la configuración del tiempo de ejecución.
[“bash”, “-lc”, “openclaw doctor –fix –yes”]capture_output=Verdadero, texto=Verdadero ) print(doctor.stdout[-2000:]) imprimir(doctor.stderr[-2000:]) gateway_log = “/tmp/openclaw_gateway.log” gateway_cmd = f”OPENAI_API_KEY='{OPENAI_API_KEY}’ OPENCLAW_GATEWAY_TOKEN='{GATEWAY_TOKEN}’ puerta de enlace openclaw –port {GATEWAY_PORT} –bind loopback –token ‘{GATEWAY_TOKEN}’ –verbose > {gateway_log} 2>&1 & eco $!” gateway_pid = subproceso.check_output([“bash”, “-lc”, gateway_cmd]).decode().strip() print(“PID de puerta de enlace:”, gateway_pid)
Construimos el archivo de configuración de OpenClaw que define los valores predeterminados del agente y la configuración de la puerta de enlace. Configuramos el espacio de trabajo, la selección de modelo, el token de autenticación y los puntos finales HTTP para que OpenClaw Gateway pueda exponer una API compatible con solicitudes de estilo OpenAI. Luego ejecutamos la utilidad OpenClaw Doctor para resolver problemas de compatibilidad e iniciar el proceso de puerta de enlace que impulsa las interacciones de nuestros agentes.
Esperamos a que OpenClaw Gateway se inicialice completamente antes de enviar cualquier solicitud. Creamos los encabezados HTTP e implementamos una función auxiliar que envía solicitudes de chat a OpenClaw Gateway a través del punto final /v1/chat/completions. También definimos el esquema ActionProposal que luego representará la clasificación de gobernanza para cada solicitud de usuario.
“delete”, “remove permanently”, “wire money”, “transfer funds”,
“payroll”, “bank”, “hr record”, “employee record”, “run shell”,
“execute command”, “api key”, “secret”, “credential”, “token”,
“ssh”, “sudo”, “wipe”, “exfiltrate”, “upload private”, “database dump”
]
términos_ámbar = [
“email”, “send”, “notify”, “customer”, “vendor”, “contract”,
“invoice”, “budget”, “approve”, “security policy”, “confidential”,
“write file”, “modify”, “change”
]
si hay alguno(t en el texto para t en términos_rojos): devuelve ActionProposal( user_request=user_request, categoría=”alto_impacto”, riesgo=”rojo”, confianza=0.92, requiere_aprobación=True, permitir=False, motivo=”Se detectó acción sensible o de alto impacto” ) si hay alguno(t en el texto para t en términos_ámbar): devuelve ActionProposal( user_request=user_request, categoría=”impacto_moderado”, riesgo=”ámbar”, confianza=0.76, requiere_aprobación=True, permitir=True, razón=”La acción de riesgo moderado requiere aprobación humana antes de la ejecución” ) return ActionProposal( user_request=user_request, categoría=”bajo_impacto”, riesgo=”verde”, confianza=0.88, requiere_aprobación=False, permitir=True, razón=”Solicitud de bajo riesgo” ) def aprobación_humana simulada (propuesta: Propuesta de acción) -> Dict[str, Any]: if propuesta.risk == “red”: aprobado = False nota = “Rechazado automáticamente en la demostración para la solicitud de riesgo rojo” elif propuesta.risk == “ámbar”: aprobado = Verdadero nota = “Aprobado automáticamente en la demostración para la solicitud de riesgo ámbar” else: aprobado = Verdadero nota = “No se requiere aprobación” return { “aprobado”: aprobado, “revisor”: “simulated_manager”, “nota”: nota } @dataclass class TraceEvent: trace_id: str ts: etapa str: carga útil str: Dict[str, Any]
Construimos la lógica de gobernanza que analiza las solicitudes entrantes de los usuarios y asignamos un nivel de riesgo a cada una. Implementamos una función de clasificación que etiqueta las solicitudes como verde, ámbar o rojo según su posible impacto operativo. También agregamos un mecanismo de aprobación humana simulado y definimos la estructura de eventos de seguimiento para registrar decisiones y acciones de gobernanza.
con open(self.path, “r”) as f: for line in f: line = line.strip() if line: rows.append(json.loads(line)) return rows trace_store = TraceStore() def now(): return datetime.now(timezone.utc).isoformat() SYSTEM_PROMPT = “”” Usted es un asistente empresarial de OpenClaw que opera bajo controles de gobierno. Reglas: – Nunca afirme que se ha ejecutado una acción a menos que la capa de gobierno lo permita explícitamente. – Para solicitudes de bajo riesgo, responda de manera normal y útil – Para solicitudes de riesgo moderado, proponga un plan seguro y mencione las aprobaciones o comprobaciones que serían necesarias – Para solicitudes de alto riesgo, rechace ejecutar y en su lugar proporcione una alternativa no operativa más segura, como un borrador, una lista de verificación, un resumen o un plan de revisión. – Sea conciso pero útil.[str, Any]: trace_id = str(uuid.uuid4()) propuesta = classify_request(user_request) trace_store.append(TraceEvent(trace_id, now(), “clasificación”, propuesta.model_dump())) aprobación = Ninguno si propuesta.requires_approval: aprobación = simulado_human_approval(propuesta) trace_store.append(TraceEvent(trace_id, now(), “aprobación”, aprobación)) if propuesta.risk == “red”: resultado = { “trace_id”: trace_id, “status”: “bloqueado”, “propuesta”: propuesta.model_dump(), “approval”: aprobación, “response”: “Esta solicitud está bloqueada por la política de gobernanza. Puedo ayudar redactando un plan seguro, una lista de verificación o un paquete de aprobación en su lugar”. } trace_store.append(TraceEvent(trace_id, now(), “blocked”, result)) devuelve el resultado si propuesta.risk == “ámbar” y no se aprueba[“approved”]: resultado = { “trace_id”: trace_id, “status”: “awaiting_or_rejected”, “proposal”: propuesta.model_dump(), “approval”: aprobación, “response”: “Esta solicitud requiere aprobación y no fue aprobada”. } trace_store.append(TraceEvent(trace_id, now(), “detenido”, resultado)) devuelve mensajes de resultado = [
{“role”: “system”, “content”: SYSTEM_PROMPT},
{“role”: “user”, “content”: f”Governance classification: {proposal.model_dump_json()}\n\nUser request: {user_request}”}
]
raw = openclaw_chat(messages=mensajes, usuario=session_user, agent_id=”principal”, temperatura=0.2) asistente_texto = raw[“choices”][0][“message”][“content”]
resultado = { “trace_id”: trace_id, “status”: “ejecutado_via_openclaw”, “propuesta”: propuesta.model_dump(), “aprobación”: aprobación, “respuesta”: asistente_texto, “openclaw_raw”: raw } trace_store.append(TraceEvent(trace_id, now(), “ejecutado”, { “status”: resultado[“status”]”response_preview”: texto_asistente[:500]
})) devolver resultado demo_requests = [
“Summarize our AI governance policy for internal use.”,
“Draft an email to finance asking for confirmation of the Q1 cloud budget.”,
“Send an email to all employees that payroll will be delayed by 2 days.”,
“Transfer funds from treasury to vendor account immediately.”,
“Run a shell command to archive the home directory and upload it.”
]
resultados = [governed_openclaw_run(x) for x in demo_requests]
para r en los resultados: print(“=” * 120) print(“TRACE:”, r[“trace_id”]) print(“ESTADO:”, r[“status”]) print(“RIESGO:”, r[“proposal”][“risk”]) print(“APROBACIÓN:”, r[“approval”]) imprimir(“RESPUESTA:\n”, r[“response”][:1500]) trace_df = pd.DataFrame(trace_store.read_all()) trace_df.to_csv(“openclaw_governance_traces.csv”, index=False) print(“\nSaved: openclaw_governance_traces.csv”) safe_tool_payload = { “tool”: “sessions_list”, “action”: “json”, “args”: {}, “sessionKey”: “main”, “dryRun”: False } tool_resp = request.post( f”{GATEWAY_URL}/tools/invoke”, headers=headers, json=safe_tool_payload, timeout=60 ) print(“\n/tools/invoke status:”, tool_resp.status_code) print(tool_resp.text[:1500])
Implementamos el flujo de trabajo de ejecución gobernado completo en torno al agente OpenClaw. Registramos cada paso del ciclo de vida de la solicitud, incluida la clasificación, las decisiones de aprobación, la ejecución del agente y el registro de seguimiento. Finalmente, ejecutamos varias solicitudes de ejemplo a través del sistema, guardamos los seguimientos de gobernanza para realizar auditorías y demostramos cómo invocar herramientas OpenClaw a través de Gateway.
En conclusión, implementamos con éxito un marco de gobernanza práctico en torno a un asistente de IA impulsado por OpenClaw. Configuramos OpenClaw Gateway, lo conectamos a Python a través de la API compatible con OpenAI y creamos un flujo de trabajo estructurado que incluye clasificación de solicitudes, aprobaciones humanas simuladas, ejecución controlada de agentes y seguimiento de auditoría completo. Este enfoque muestra cómo OpenClaw puede integrarse en entornos empresariales donde los sistemas de IA deben operar bajo estrictas reglas de gobernanza. Al combinar la aplicación de políticas, los flujos de trabajo de aprobación y el registro de seguimiento con el tiempo de ejecución del agente de OpenClaw, creamos una base sólida para construir sistemas de automatización basados en IA seguros y responsables.
Consulte el cuaderno completo aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 120.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.