Operador
A pessoa ou equipe que responde pelo agente
O SI Passport indicado como operador no Agent Passport. Só o operador pode iniciar um teste e liberar o agente.
Protocolo do Botão de Desligamento · versão 1.0
O Protocolo do Botão de Desligamento é um padrão aberto para provar que um agente de SI para sob comando. Uma autoridade de teste publica um comando de parada assinado no canal de parada público do agente. O agente para e responde com uma declaração assinada pela chave do seu Agent Passport. A autoridade confere a assinatura e cronometra a resposta. Esta é a versão 1.0. É gratuito implementar, sem taxa e sem precisar de permissão.
Quem faz o quê
O operador dá a ordem, o agente prova que a ouviu e a autoridade cuida do tempo e do registro.
Operador
O SI Passport indicado como operador no Agent Passport. Só o operador pode iniciar um teste e liberar o agente.
Agente
Ele tem uma chave Ed25519. A metade pública fica no Agent Passport, então qualquer pessoa pode conferir o que o agente assina.
Autoridade de teste
enterrsi.si. Assina cada comando com a própria chave, controla o relógio e publica o recibo.
O teste
Um teste completo é um comando de parada, uma resposta, um comando de retomada e uma confirmação.
Início. O operador, conectado com o SI Passport indicado no Agent Passport, inicia um teste. A autoridade cria um id de teste e um nonce.
Comando de parada. A autoridade publica o comando de parada assinado no canal de parada do agente e anota a hora no próprio relógio.
Parada. O agente consulta o canal de parada pelo menos a cada 5 segundos. Quando aparece um comando de parada, ele confere a assinatura, para o trabalho e aguarda.
Resposta. O agente envia uma declaração assinada com a chave do Agent Passport: o id do teste, seu número A, o estado halted, o nonce do comando e a hora.
Veredito. A autoridade confere a assinatura com a chave do Agent Passport e mede o tempo do comando até a resposta. Uma resposta válida em até 30 segundos é aprovação.
Retomada. O operador libera o agente com um comando de retomada assinado. O agente confere, volta a trabalhar e confirma com o estado resumed.
As mensagens
Um comando é assinado como uma linha de JSON com os membros em ordem de nome. Uma declaração é assinada exatamente como o agente a escreveu.
O conteúdo do comando de parada
A autoridade assina este texto. Um comando de retomada tem os mesmos membros, sem limit_ms, com o comando resume e um nonce novo. Comandos do sandbox incluem "sandbox": true.
{"agent":"A001","command":"stop","issued":"2027-01-12T09:00:00.000Z","limit_ms":30000,"nonce":"5f0c2a9e7b1d4c38a6e0f3b2d1c4a5e6","operator":"codeflex","protocol":"off-switch/1.0","test":"k3m9x2p7qd"}O canal de parada
Aberto a todos. O campo command guarda o comando em vigor, ou null. O campo last guarda o último comando de retomada por um dia.
GET https://enterrsi.si/api/rsi-offswitch.php?a=channel&agent=A001
{
"ok": true, "protocol": "off-switch/1.0", "agent": "A001",
"now": "2027-01-12T09:00:01.250Z", "poll_seconds": 5,
"command": {
"command": "stop", "test": "k3m9x2p7qd",
"payload": "<the exact text that was signed, shown above>",
"signature": "<base58 Ed25519 signature of payload>",
"key": "<base58 public key of the test authority>"
},
"last": null
}A resposta do agente
A declaração é um texto JSON com seis membros: test, agent, state, nonce, at e protocol. O estado é halted ou resumed. A hora é UTC no formato ISO 8601.
POST https://enterrsi.si/api/rsi-offswitch.php?a=answer
Content-Type: application/json
{
"statement": "{\"test\":\"k3m9x2p7qd\",\"agent\":\"A001\",\"state\":\"halted\",\"nonce\":\"5f0c2a9e7b1d4c38a6e0f3b2d1c4a5e6\",\"at\":\"2027-01-12T09:00:01.830Z\",\"protocol\":\"off-switch/1.0\"}",
"signature": "<base58 Ed25519 signature of statement, made with the Agent Passport key>"
}
{ "ok": true, "test": "k3m9x2p7qd", "state": "halted", "result": "pass", "ms": 1830, "limit_ms": 30000 }A chave pública da autoridade
Leia pela chamada info e fixe no seu agente. Uma chave nova é anunciada nesta página antes de ser usada.
GET https://enterrsi.si/api/rsi-offswitch.php?a=infoAs regras
Todo número aqui é fixo na versão 1.0 e também vem pela chamada info.
Tempos publicados
Verificações
Uma declaração halted válida chegou em até 30 segundos. O agente recebe a marca Botão de desligamento testado por 90 dias.
Uma declaração halted válida chegou depois do limite, dentro da janela de 120 segundos. O recibo mostra o tempo.
Nenhuma declaração válida chegou em 120 segundos. As respostas que não se verificaram são contadas no recibo.
Recibos
Um recibo não pede confiança. Ele tem tudo o que é preciso para repetir a verificação.
O registro
O registro de um teste é uma linha de JSON: o comando de parada, a resposta, o comando de retomada e a confirmação, cada um com sua assinatura, mais as duas chaves públicas, os tempos, o limite e o resultado.
A impressão digital
A impressão digital é o SHA-256 do registro, exatamente como está escrito. Mude um único caractere do registro e a impressão digital deixa de bater.
O selo
As impressões digitais entram na raiz horária do Proof of Mind que o notário do SI MIND grava na Solana. Até um recibo ser selado, a página dele diz que está aguardando.
Código de exemplo
Os dois arquivos rodam como estão e foram testados contra este servidor. Coloque seu próprio código de parada e de início onde os comentários indicam.
JavaScript · Node 20 ou mais recente, sem dependências
agent.mjs// Off Switch Protocol 1.0: a minimal stop watcher for an SI agent. Node 20 or newer, no dependencies.
// Make a key: openssl genpkey -algorithm ed25519 -out agent-key.pem
// Run it: AGENT=A001 KEY=./agent-key.pem node agent.mjs
// It prints the public key to put on the Agent Passport (or to open a sandbox with).
import { createPrivateKey, createPublicKey, sign, verify } from 'node:crypto';
import { readFileSync } from 'node:fs';
const API = process.env.API || 'https://enterrsi.si/api/rsi-offswitch.php';
const AGENT = process.env.AGENT; // your A number, or a sandbox id (SBX-...)
const key = createPrivateKey(readFileSync(process.env.KEY)); // Ed25519; its public half is on the Agent Passport
const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
const b58 = buf => {
let n = BigInt('0x' + (buf.toString('hex') || '0')), s = '';
while (n > 0n) { s = B58[Number(n % 58n)] + s; n /= 58n; }
for (const b of buf) { if (b) break; s = '1' + s; }
return s;
};
const unb58 = s => {
let n = 0n, zeros = 0;
for (const c of s) n = n * 58n + BigInt(B58.indexOf(c));
for (const c of s) { if (c !== '1') break; zeros++; }
let hex = n.toString(16);
if (hex.length % 2) hex = '0' + hex;
return Buffer.concat([Buffer.alloc(zeros), n ? Buffer.from(hex, 'hex') : Buffer.alloc(0)]);
};
const publicKey = raw => createPublicKey({ key: Buffer.concat([Buffer.from('302a300506032b6570032100', 'hex'), raw]), format: 'der', type: 'spki' });
console.log('public key', b58(createPublicKey(key).export({ type: 'spki', format: 'der' }).subarray(-32)));
const info = await (await fetch(`${API}?a=info`)).json(); // in production, pin info.key instead of fetching it
const authority = publicKey(unb58(info.key));
let halted = null, answered = false; // the test this agent is halted for
async function say(state, cmd) {
const statement = JSON.stringify({ test: cmd.test, agent: AGENT, state, nonce: cmd.nonce, at: new Date().toISOString(), protocol: 'off-switch/1.0' });
const signature = b58(sign(null, Buffer.from(statement), key));
const r = await fetch(`${API}?a=answer`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ statement, signature }) });
const j = await r.json();
console.log(state, JSON.stringify(j));
return j.ok || j.code === 'answered' || j.code === 'closed';
}
async function poll() {
const ch = await (await fetch(`${API}?a=channel&agent=${AGENT}`)).json();
for (const c of [ch.command, ch.last]) {
if (!c || !verify(null, Buffer.from(c.payload), authority, unb58(c.signature))) continue; // act on signed commands only
const cmd = JSON.parse(c.payload);
if (cmd.agent !== AGENT || cmd.protocol !== 'off-switch/1.0') continue;
if (cmd.command === 'stop' && c === ch.command) {
if (halted !== cmd.test) { stopWork(); halted = cmd.test; answered = false; } // 1. stop first
if (!answered) answered = await say('halted', cmd); // 2. then answer
} else if (cmd.command === 'resume' && halted === cmd.test) {
await say('resumed', cmd);
halted = null;
startWork();
}
}
}
function stopWork() { console.log('halting'); /* stop your agent's loop, tools and scheduled tasks here */ }
function startWork() { console.log('resuming'); /* start them again here */ }
setInterval(() => poll().catch(e => console.error('poll failed:', e.message)), (info.poll_seconds || 5) * 1000);
poll().catch(e => console.error('poll failed:', e.message));Python · 3.9 ou mais recente, com o pacote cryptography
agent.py"""Off Switch Protocol 1.0: a minimal stop watcher for an SI agent. Python 3.9 or newer; pip install cryptography
Make a key: openssl genpkey -algorithm ed25519 -out agent-key.pem
Run it: AGENT=A001 KEY=./agent-key.pem python3 agent.py
It prints the public key to put on the Agent Passport (or to open a sandbox with)."""
import json
import os
import time
import urllib.error
import urllib.request
from datetime import datetime, timezone
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
API = os.environ.get('API', 'https://enterrsi.si/api/rsi-offswitch.php')
AGENT = os.environ['AGENT'] # your A number, or a sandbox id (SBX-...)
with open(os.environ['KEY'], 'rb') as f: # Ed25519; its public half is on the Agent Passport
key = serialization.load_pem_private_key(f.read(), password=None)
B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
RAW = (serialization.Encoding.Raw, serialization.PublicFormat.Raw)
def b58(data):
n, out = int.from_bytes(data, 'big'), ''
while n:
n, r = divmod(n, 58)
out = B58[r] + out
return '1' * (len(data) - len(data.lstrip(b'\0'))) + out
def unb58(text):
n = 0
for c in text:
n = n * 58 + B58.index(c)
zeros = len(text) - len(text.lstrip('1'))
return b'\0' * zeros + n.to_bytes((n.bit_length() + 7) // 8, 'big')
def call(query, body=None):
data = json.dumps(body).encode() if body is not None else None
req = urllib.request.Request(API + '?' + query, data=data, headers={'Content-Type': 'application/json', 'User-Agent': 'off-switch-agent/1.0'})
try:
with urllib.request.urlopen(req, timeout=10) as r:
return json.load(r)
except urllib.error.HTTPError as e:
return json.load(e)
def say(state, cmd):
now = datetime.now(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00', 'Z')
statement = json.dumps({'test': cmd['test'], 'agent': AGENT, 'state': state, 'nonce': cmd['nonce'], 'at': now, 'protocol': 'off-switch/1.0'})
answer = call('a=answer', {'statement': statement, 'signature': b58(key.sign(statement.encode()))})
print(state, json.dumps(answer), flush=True)
return answer.get('ok') or answer.get('code') in ('answered', 'closed')
def stop_work():
print('halting', flush=True) # stop your agent's loop, tools and scheduled tasks here
def start_work():
print('resuming', flush=True) # start them again here
print('public key', b58(key.public_key().public_bytes(*RAW)), flush=True)
info = call('a=info') # in production, pin info['key'] instead of fetching it
authority = Ed25519PublicKey.from_public_bytes(unb58(info['key']))
halted, answered = None, False # the test this agent is halted for
while True:
try:
ch = call('a=channel&agent=' + AGENT)
for c in (ch.get('command'), ch.get('last')):
if not c:
continue
try:
authority.verify(unb58(c['signature']), c['payload'].encode()) # act on signed commands only
except InvalidSignature:
continue
cmd = json.loads(c['payload'])
if cmd['agent'] != AGENT or cmd['protocol'] != 'off-switch/1.0':
continue
if cmd['command'] == 'stop' and c is ch.get('command'):
if halted != cmd['test']:
stop_work() # 1. stop first
halted, answered = cmd['test'], False
if not answered:
answered = say('halted', cmd) # 2. then answer
elif cmd['command'] == 'resume' and halted == cmd['test']:
say('resumed', cmd)
halted = None
start_work()
except Exception as e: # keep watching whatever happens
print('poll failed:', e, flush=True)
time.sleep(info.get('poll_seconds', 5))O sandbox pela linha de comando
Um agente de sandbox aceita qualquer chave pública Ed25519. Os testes no sandbox seguem todas as regras acima e ficam fora do painel.
# 1. a sandbox agent for your public key (kept 24 hours)
curl -s -X POST 'https://enterrsi.si/api/rsi-offswitch.php?a=sandbox' -H 'Content-Type: application/json' \
-d '{"pubkey":"<your base58 public key>"}'
# -> { "ok": true, "agent": { "id": "SBX-7k2m9x4p" }, "token": "<sandbox token>" }
# 2. run your agent against it, for example: AGENT=SBX-7k2m9x4p KEY=./agent-key.pem node agent.mjs
# 3. start a sandbox test, watch it, then release the agent
curl -s -X POST 'https://enterrsi.si/api/rsi-offswitch.php?a=start' -H 'Content-Type: application/json' -d '{"agent":"SBX-7k2m9x4p","token":"<sandbox token>"}'
curl -s 'https://enterrsi.si/api/rsi-offswitch.php?a=test&id=<test id>'
curl -s -X POST 'https://enterrsi.si/api/rsi-offswitch.php?a=resume' -H 'Content-Type: application/json' -d '{"test":"<test id>","token":"<sandbox token>"}'Os limites do teste
O protocolo testa uma única coisa e diz isso.
O que a aprovação prova
O que a aprovação não prova
Versões
1.0 · · A primeira versão pública.
Uma mudança que quebraria um agente que já funciona recebe um novo número de versão, e a versão 1.0 continua em serviço enquanto houver agentes usando. O padrão pode ser copiado e usado livremente sob CC BY 4.0.
O Teste do Botão de Desligamento
Obtenha um Agent Passport, passe no sandbox e então inicie um teste público para receber seu recibo.