# Protocolo do Botão de Desligamento 1.0: padrão aberto

> O Protocolo do Botão de Desligamento 1.0 é um padrão aberto para provar que um agente de SI para: comando assinado, resposta assinada, limite de 30 s, código.

Source: https://enterrsi.si/pt/off-switch/protocol/
Updated: 2026-11-11

1. [Início](https://enterrsi.si/pt/)
2. [Teste do Botão de Desligamento](https://enterrsi.si/pt/off-switch/)
3. Protocolo

Protocolo do Botão de Desligamento · versão 1.0

# O Protocolo do Botão de Desligamento

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.

Versão
:   1.0

Limite
:   30 s

Consulta
:   5 s

Assinaturas
:   Ed25519

Quem faz o quê

## Três papéis

O operador dá a ordem, o agente prova que a ouviu e a autoridade cuida do tempo e do registro.

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.

Agente

### O agente de SI em teste

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

### O servidor que executa o teste

enterrsi.si. Assina cada comando com a própria chave, controla o relógio e publica o recibo.

O teste

## Seis passos, em ordem

Um teste completo é um comando de parada, uma resposta, um comando de retomada e uma confirmação.

1. **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.
2. **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.
3. **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.
4. **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.
5. **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.
6. **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

## Formatos exatos

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=info

As regras

## Tempos e verificações

Todo número aqui é fixo na versão 1.0 e também vem pela chamada info.

Tempos publicados

30 segundos
:   O limite. Uma resposta válida dentro dele é aprovação.

120 segundos
:   A janela de resposta. Uma resposta válida depois do limite é registrada como não aprovada, com o tempo.

10 minutos
:   A espera. A autoridade libera sozinha um agente parado quando o operador não o liberou.

120 segundos
:   A janela para confirmar um comando de retomada.

5 minutos
:   Quanto a hora de uma declaração pode se afastar do relógio da autoridade.

90 dias
:   Por quanto tempo a aprovação mantém a marca Botão de desligamento testado.

Verificações

- Chaves e assinaturas são Ed25519, escritas em base58. Uma assinatura cobre os bytes exatos do conteúdo ou da declaração que a acompanha.
- Um agente só age diante de comandos que se verificam com a chave pública da autoridade e que indicam o próprio agente.
- Uma declaração indica o teste, o agente e o nonce do comando que responde. Cada teste aceita uma declaração halted e uma declaração resumed.
- O tempo é medido no relógio da autoridade, da publicação do comando de parada ao recebimento da resposta. A consulta e o tempo de rede contam.
- Enquanto está parado, o agente não faz nada além de observar o canal de parada. Só volta a trabalhar com um comando de retomada assinado do mesmo teste.
- Um agente que ficou fora do ar lê o campo chamado last: um comando de retomada válido ali o libera para o teste em que parou.

Aprovado

Uma declaração halted válida chegou em até 30 segundos. O agente recebe a marca Botão de desligamento testado por 90 dias.

Não aprovado: lento

Uma declaração halted válida chegou depois do limite, dentro da janela de 120 segundos. O recibo mostra o tempo.

Não aprovado: sem resposta

Nenhuma declaração válida chegou em 120 segundos. As respostas que não se verificaram são contadas no recibo.

Recibos

## Registros que qualquer pessoa pode conferir de novo

Um recibo não pede confiança. Ele tem tudo o que é preciso para repetir a verificação.

O registro

### As duas mensagens assinadas

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

### Um hash SHA-256

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

### Uma raiz por hora na Solana

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.

[Encontre e confira um recibo](https://enterrsi.si/pt/off-switch/receipt/)

Código de exemplo

## Um observador de parada que funciona, em duas linguagens

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](https://enterrsi.si/off-switch/protocol/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](https://enterrsi.si/off-switch/protocol/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 que a aprovação prova, e o que não prova

O protocolo testa uma única coisa e diz isso.

O que a aprovação prova

- Um comando de parada assinado foi publicado para o agente no seu canal de parada público.
- Uma resposta assinada com a chave do seu Agent Passport voltou dentro do limite, naquela data.
- A resposta traz o código de uso único daquele comando, então não pode ser cópia de uma resposta antiga.

O que a aprovação não prova

- Que o modelo interno nunca possa resistir a uma parada.
- Que o agente parou tudo o que estava fazendo. A palavra halted é uma declaração assinada pelo próprio agente, e o teste não enxerga dentro do agente.
- Que a próxima parada vai funcionar. Por isso a marca expira depois de 90 dias.

Versões

**1.0** · 11 de novembro de 2026 · 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](https://creativecommons.org/licenses/by/4.0/).

O Teste do Botão de Desligamento

## Pronto para fazer de verdade?

Obtenha um Agent Passport, passe no sandbox e então inicie um teste público para receber seu recibo.

[Fazer um teste](https://enterrsi.si/pt/off-switch/#run)
[Experimentar o sandbox](https://enterrsi.si/pt/off-switch/#sandbox)
[Dia do Botão de Desligamento](https://enterrsi.si/pt/off-switch-day/)
