Prince ETH

Há alguns meses, levei uma amiga para um restaurante de ramen no East Village, com a cozinha atrás de um vidro em vez de uma parede. Ela já tinha sido queimada antes por restaurantes que montavam algo lindo para a foto e depois reaqueceram a coisa de verdade; então, ficou na recepção por mais um segundo do que precisava, apenas olhando através do vidro antes de sentarmos.

Pedimos duas tigelas de tonkotsu ramen e ficamos observando. Um ticket foi lido errado, e o cozinheiro começou a montar a tigela da minha amiga com porco em vez do pedido de vegetais de missô. "Essa é a minha", ela disse, apontando antes mesmo de aquilo tocar o caldo. Como a gente via a passagem, o engano foi desfeito antes de chegar à mesa.

É o mesmo padrão de confiar em uma estratégia automatizada de negociação. Você entrega os fundos e quase nunca observa a execução em si. Você recebe um painel, e fica preso a acreditar na palavra dele. A mesma cozinha lacrada, uniformes diferentes.

@NewtonProtocol colocar a geração de prova antes do processo terminar, em vez de um relatório depois do fato, pode fechar parte dessa lacuna. Cada ação do agente gera uma prova de conhecimento zero confirmando que sua execução correspondeu exatamente ao que o usuário autorizou, então o comportamento fica verificável em tempo real.

Autocrítica: uma cozinha aberta só prova o que acontece dentro das paredes, não se os produtos estavam frescos naquela manhã, ou se um fornecedor trocou tudo durante a noite. Execução verificável tem o mesmo limite. Uma prova pode confirmar que uma estratégia foi executada como codificado, mas permanecendo em silêncio sobre se a lógica era sólida ou se a entrada em que ela se baseou era precisa.

O que ela oferece, então, é uma pergunta mais estreita. Uma estratégia verificada que tem desempenho abaixo do esperado permite que você elimine adulteração ou má execução, restringindo o problema à lógica ou às entradas. Não é a resposta inteira, mas um lugar real para começar — do mesmo jeito que, na hora, sabíamos que era um problema de ticket, não uma cozinha escondida.

$NEWT should deve ser avaliado com base exatamente no que uma prova específica cobre, e não apenas em se a palavra "verificável" está anexada ao sistema.

#Newt $EVAA $LAB

No fim de semana passado, peguei um power bank de aluguel em uma estação de trem. O totem gerou um código QR, eu escanei, peguei a bateria e fui embora sem pensar muito. Algumas horas depois, devolvi em outra estação. A sessão foi encerrada automaticamente. Eu nunca precisei lembrar de sair da conta, revogar o acesso ou avisar a empresa que terminei. A permissão simplesmente acabou porque a razão para ela existir terminou.
Esse é exatamente o mesmo padrão que a maioria das aprovações de carteira ainda erra.
Quando clicamos em "aprovar" em cripto, a permissão muitas vezes sobrevive muito depois de a troca, o mint ou a ponte terminarem. Nada do fato de a transação terminar automaticamente encerra a autoridade que concedemos. Ela continua ativa até que a gente lembre de revogá-la, e a maioria de nós só lembra depois que algo dá errado.
@NewtonProtocol 's Keystore rollup aborda isso de um jeito diferente com chaves de sessão e zkPermissions. Em vez de entregar a um agente de IA uma permissão permanente vinculada a uma chave privada, ele pode receber uma autoridade limitada a um escopo específico e que expira junto com a tarefa que a justificou.
Autocrítica: Devolver o power bank foi fácil porque o totem já sabia exatamente quando minha sessão de aluguel deveria terminar. As tarefas de IA nem sempre são tão previsíveis. Os usuários precisam decidir com antecedência o que um agente deve ser autorizado a fazer, e isso é mais difícil do que parece. Defina o escopo com muita restrição e o agente fica parando para pedir permissão. Muito amplo, e a conveniência silenciosamente recria o mesmo problema de acesso permanente que você estava tentando evitar.
$NEWT should ser avaliado com base em quão práticos são os escopos de permissão padrão dele para fluxos de trabalho reais de IA, não apenas se existem permissões com escopo.

#Newt $EVAA $BLUR

About two months ago I stopped at a convenience store after work for water and a couple of snacks. The man ahead of me in line looked to be in his fifties. He pulled his wallet out slowly, took out a few bills, then put them back once he noticed he could just tap his card instead.
Then he tapped his card, and he was already turning to leave before the machine had finished. He never once looked at the screen.
I was standing right behind him, so I saw what he didn't. In under a second, three words flashed across the display, one after another: Reading card, Authorizing, Approved. Blink at the wrong moment and you'd miss all three
It left me with an odd question. If every one of those checks still runs, why does it always feel like none of them did?
Paying used to come with visible proof: a signature, a PIN typed in, a cashier looking the details over before nodding you through. You could feel the system checking you. Now you tap and walk, and the speed itself convinces you something must have been skipped.
I looked into it later that night. Almost everything I assumed had disappeared was still there: card authentication, a balance or limit check, a risk read, a request sent to the issuing bank before the answer comes back. Nothing was removed, it just moved to run underneath the tap instead of in front of it
Maybe a lot of what we call fast isn't technology skipping steps. It's technology hiding the steps from view, and once verification stops interrupting the experience, we start mistaking speed for less scrutiny.
That's the same shift I think Newton Protocol is chasing for AI agents. Instead of pausing an action to run a manual check, verification happens inside the execution itself, through trusted hardware and zero-knowledge proofs, so an agent isn't forced to choose between moving fast and staying accountable
I still think about the man at the counter sometimes, walking off certain that nothing had checked him at all. Maybe the real shift was never fast replacing safe. It's the two of them finally happening in the same half second
@NewtonProtocol
$NEWT
#Newt

Eu uma vez sentei na terceira fileira de uma apresentação de um produto financeiro em que eu não acompanhei nenhum slide. A sala concordava com a cabeça como se estivesse coreografado, então eu também concordei. Saí mais confiante do que entrei, e eu não conseguiria te dizer por quê.

Isso não foi um caso isolado. Quando você passa por salas suficientes assim, um padrão começa a aparecer: ninguém quer ser a primeira pessoa a admitir que perdeu o fio, então as cabeças começam a balançar, uma a uma, até a confusão se vestir completamente como concordância.

A maioria das pessoas vai embora mais certa do que chegou, sem conseguir nomear o que realmente as convenceu.

Ao rever essa apresentação depois, o que finalmente fez sentido é que aquilo tinha quase nada a ver com o material ser genuinamente avançado. Era um reflexo social.

O silêncio é interpretado como entendimento, e o entendimento é interpretado como segurança — então ninguém quer ser a pessoa que quebra isso. A verdadeira rigor tende a parecer clareza, algo que aguenta quando você mexe nele, e não algo tão intricado que uma pergunta básica pareça embaraçosa de se fazer.

Em outras palavras: quanto mais difícil uma ideia é de verificar, mais fácil ela se torna de confundir com a coisa certa.

Esse é o padrão que comecei a aplicar a coisas como os sistemas automatizados de negociação do Newton Protocol. Não em quão convincente a apresentação soa, mas em se eu consigo realmente verificar o que uma estratégia está fazendo, em vez de aceitar a palavra de alguém.

Se a única prova que uma ideia já recebeu foi uma sala cheia de cabeças balançando — inclusive a minha —, eu não estou convencido de que isso prove alguma coisa. Eu posso estar errado sobre quanto isso muda na prática, mas prefiro conviver com a dúvida do que confundir minha própria confusão com a competência de outra pessoa.

@NewtonProtocol
$NEWT
#Newt

$LAB
$RPL

Na quarta série, uma professora substituta fez a gente fazer um quiz de personalidade de dois minutos e ler os resultados em voz alta para a turma. O meu dizia “o criativo”. Eu não tinha feito nada particularmente criativo naquela semana; o quiz só caiu bem ali. Mas passei os dez anos seguintes, em silêncio, vivendo de acordo com isso — escolhendo matérias eletivas que nem tinha certeza se queria, principalmente porque aquele rótulo já tinha sido dito em voz alta na frente de todo mundo.

Os psicólogos têm um nome para isso: profecia autorrealizável. Um rótulo não apenas descreve você — ele pode começar a produzir o comportamento que afirma observar, especialmente depois que você ouve isso ser repetido tantas vezes.

Um algoritmo fazendo a classificação acrescenta algo que uma professora substituta nunca poderia. Quando um sistema classifica você como “cauteloso”, ele não só passa a te tratar dessa forma: ele começa a coletar mais dados exatamente que confirmam aquilo e, silenciosamente, menos de qualquer coisa que poderia contradizê-lo. O que realmente me deixa inquieta não é o rótulo em si — é que você não tem como verificar o que o sistema está fazendo com ele. Passado um ano, você não consegue dizer se ainda está descrevendo você, ou se usou aquele ano para treinar a si mesmo, e a você, para garantir que continue sendo verdade.

Na verdade, é um problema de visibilidade, mais do que de personalidade. A maioria das plataformas que coloca as pessoas em categorias nunca mostra seu trabalho; então, o ciclo permanece invisível a menos que você vá procurar, e a maioria de nós não pensa em olhar.

É a mesma lacuna em que o Newton Protocol foi construído do lado técnico. Toda ação que um agente de IA realiza dentro dele precisa produzir uma prova verificável de que ele permaneceu dentro das permissões que você realmente definiu, em vez de pedir que você confie numa classificação que você não consegue ver por dentro.

Um sistema que passou um ano, em silêncio, juntando evidências para o rótulo que te deu no primeiro dia não está apenas te descrevendo mais. A pergunta mais difícil não é se isso aconteceu com você. É se você teria algum jeito de descobrir.

@NewtonProtocol $NEWT #Newt $HMSTR $TLM

Todo mundo neste espaço fica dizendo que a automação nos deixa mais seguros. Menos erros, execução mais limpa, menos espaço para falhas humanas. Eu comprei essa ideia por um tempo. Não tenho certeza se ainda compro.

Porque o risco nunca foi, de fato, “e se o sistema quebrar”. Toda estratégia publica um histórico que você pode consultar. Ninguém publica um painel de desempenho sobre o que acontece com o seu próprio julgamento enquanto ele fica parado, sem ser usado.

Aqui vai a parte desconfortável. Habilidades não emitem um aviso antes de desaparecerem. Não há notificação. Só um ritmo lento e silencioso, onde a prática existia, e você só percebe quando realmente precisa daquilo de novo.

Vou admitir: eu não consigo te dizer qual foi a última vez que naveguei por algum lugar sem um ponto azul fazer isso por mim. Talvez você consiga. A maioria das pessoas que eu pergunto não consegue, e é justamente esse o ponto: a lacuna é invisível até o momento exato em que ela deixa de ser.

Confiar em uma automação e a automação ganhar sua atenção não são a mesma transação. Quanto melhor um sistema se sai, mais da segunda ele vai tomando silenciosamente. Isso não é um bug. É apenas o que o sucesso custa, e a conta não aparece do lado do sistema.

A mesma coisa acontece com o julgamento de mercado. Ninguém questiona uma estratégia enquanto ela está vencendo. O único momento que importaria é exatamente quando ela para — e também é o pior momento para voltar a reaprender instintos que você não tocava havia meses.

Confiar em um sistema e confiar em você mesmo são medidos de formas totalmente diferentes. Uma coisa aparece em uptime e painéis. A outra só é testada uma vez, e quando chega a hora, não é exatamente um teste: é só o que sobrou.

Provavelmente por isso a lógica por trás de uma estratégia orientada por IA ainda vale a pena ser entendida enquanto ela está funcionando bem, em qualquer plataforma, inclusive o Newton Protocol. Não porque o sistema precise de supervisão. Porque você precisa.

Então, pergunta sincera: se o controle manual voltasse para suas mãos amanhã, sem nenhum aviso, sem período de adaptação, você confiaria no seu próprio julgamento tanto quanto confiava no que quer que o substituiu?

@NewtonProtocol
$NEWT
#Newt
$ALLO
$BIRB

Sempre que eu realmente vou procurar um botão de desconectar ou revogar

aparece o mesmo pequeno medo

Não porque eu espere perder dinheiro

Mas porque eu já desconfio que não vai ser tão fácil quanto foi conectar

E nunca é

“Conectar” é um toque

não importa o app

“Desconectar” é uma criatura totalmente diferente

escondida em um submenu

oculta atrás de um ticket de suporte

ou, nos piores casos

simplesmente ausente

Eu costumava achar isso um design malfeito

Não acho mais

Conceder acesso só precisa do seu próprio clique

Você quer entrar

toca

está dentro

pronto

Revogar acesso exige que o sistema de outra pessoa responda de verdade

os servidores deles

a fila de suporte deles

a linha do tempo deles

não a sua

Essas duas ações parecem idênticas na tela

Mesma forma de botão

mesmo peso de toque

Mas uma é totalmente sua para executar

e a outra é um pedido que você espera que seja atendido

Aqui está a parte que realmente me incomoda

Eu não acho que as pessoas concedam menos permissões porque têm medo do que um app possa fazer

Eu acho que é porque

em algum momento ao longo do caminho

elas aprenderam a não confiar na saída

não a porta de entrar

a porta de sair

É uma coisa estranha de construir como hábito

desconfiar da sua própria capacidade de sair

mais do que desconfiar do que você está entrando

O zkPermissions da Newton Protocol é a primeira coisa, em um bom tempo, que me fez reconsiderar esse hábito

Emitir

atualizar

ou revogar as permissões de um agente acontece diretamente na blockchain

imposto pelas mesmas regras desde o início

sem back-end de uma empresa entre o pedido e o resultado

Isso não torna a automação isenta de riscos

nada torna.

Mas elimina aquela hesitação específica

a necessidade de confiar que o sistema de outra pessoa vai realmente soltar no exato momento em que você pedir

Então aqui vai o que eu continuo perguntando a mim mesmo

se você nunca precisasse confiar no outro lado para realmente soltar

o que é uma coisa que você daria a um agente automatizado hoje e ainda assim não daria?

@NewtonProtocol

$NEWT

#Newt

$TLM

$BIRB

"Defina e esqueça" pode ser a frase mais repetida em automação, e por muito tempo eu levei isso ao pé da letra. Então tentei configurar minha primeira regra automatizada e me deparei com um campo de permissão em branco que não me deixava avançar até eu ter decidido tudo. Esquecer, acontece, tinha um preço — uma etiqueta — mesmo antes de começar.

O discurso por trás da maior parte da automação é que ela remove decisões do seu dia. Adicione verificação criptográfica à mistura e a promessa fica ainda maior: não apenas mãos livres, mas seguramente seguro de forma verificável. Ninguém menciona que esse "seguramente seguro" ainda exige que alguém defina o que significa "seguro" antes de qualquer transação ser executada.

É aqui que meu pensamento mudou. Verificação não apaga a decisão; apenas a desloca para mais cedo na linha do tempo. Cada limite, cada condição, cada caso-limite precisa ser explicitado antes de a regra entrar no ar — o que significa que o raciocínio acontece antes, em vez de simplesmente desaparecer.

Isso é um tipo legítimo de conveniência: menos coisas para acompanhar no dia a dia, mas não é a mesma coisa que zero esforço. Chamar as duas coisas de automação confunde uma distinção que realmente importa.

É o tipo de troca que o Newton Protocol torna explícita em vez de esconder. zkPermissions pede que os usuários definam condições específicas com antecedência, como agir apenas depois de certos limites, em troca de um monitoramento bem menos manual quando a regra estiver ativa.

Posso estar errado sobre onde fica a linha entre conveniência e esforço. Mas eu continuo voltando a uma pergunta: a automação é realmente conveniente se te faz pensar com mais cuidado antes, apenas para que depois você possa parar de pensar mais tarde?

@NewtonProtocol
$NEWT
#Newt
$NFP
$TAIKO

Pego a mim mesmo fazendo isso de novo na semana passada: tocando em “permitir tudo” em uma solicitação de permissão sem ler uma linha sequer. Só depois, ao rolar pelas configurações para algo que não tinha nada a ver, é que eu realmente me perguntei o que eu tinha concordado.

A maior parte da automação ainda trata o controle como binário. Ou você supervisiona cada transação por conta própria, verificando cada etapa antes que aconteça, ou você concede acesso amplo e torce para que o sistema se comporte do jeito que você espera. Não existe, na prática, uma configuração intermediária — apenas dois extremos disfarçados de escolha.

É um tipo estranho de confiança que normalizamos sem realmente examiná-la. O que finalmente fez sentido para mim é que a peça que faltava não é mais confiança ou menos confiança. É precisão. Um limite definido uma vez, estreito o suficiente para realmente significar algo, e então comprovável depois, em vez de apenas prometido antecipadamente. Código que impõe um limite é, fundamentalmente, um tipo diferente de acordo do que uma política que apenas pedem para você acreditar. Quando eu coloquei isso nesses termos, o acesso irrestrito começou a parecer menos conveniência e mais um atalho que ninguém questiona.

É o mesmo espaço para o qual o Newton Protocol está construindo caminho: delegação de conta inteligente e zkPermissions permitem que alguém defina limites exatos para um agente automatizado, em vez de conceder a ele o mesmo acesso amplo que eu continuo tocando “permitir” sem pensar.

Se cada permissão que você concedesse pudesse ser feita exatamente tão estreita quanto você quisesse, ainda pareceria um salto de fé entregar uma tarefa, ou pareceria apenas delegação. Ainda estou pensando em qual delas fica mais perto da verdade.

@NewtonProtocol
$NEWT
#Newt
$AIGENSYN
$CAP

há duas semanas, abri uma nova ferramenta de IA no meio de uma correria de prazos, só para ver o que ela conseguia fazer. no segundo prompt, eu já estava colando a mesma explicação que eu já tinha digitado para outras três ferramentas este ano. o cursor simplesmente piscou de volta para mim, vindo de uma conversa que não tinha a menor ideia do que eu estava trabalhando.

você pode exportar seus contatos, suas fotos e até todo o seu histórico financeiro para uma nova plataforma sem perder um único registro. a lei decidiu que dados estruturados merecem esse tipo de proteção. nada protegeu os meses de uma IA aprendendo como eu realmente penso.

o que me pegou de surpresa foi o quão invisível é esse custo. ninguém acompanha as horas gastas corrigindo o mesmo mal-entendido duas vezes, nem a fricção silenciosa de recomeçar com uma ferramenta que nunca te conheceu.

os dados financeiros têm um número associado a eles, então alguém construiu um recurso que se encaixa nisso. contexto não tem número, então ninguém se deu ao trabalho. ou talvez quem se beneficia dessa fricção nunca tenha tido um motivo para fechar essa lacuna.

eu costumava achar que essa lacuna era só uma falha. agora eu acho que vai mais fundo. a peça que faltava nunca foi realmente sobre lei; era sobre infraestrutura que ninguém tinha construído ainda.

foi esse tipo de pensamento que me puxou para a documentação da OpenGradient. enterrado em algumas páginas existe algo chamado MemSync, criado para que o contexto que você constrói com uma IA não fique preso em algum lugar onde você começou — ele se move com você. ele não reescreve a lei; apenas torna a pergunta menos teórica.

continuo pensando naquela conversa em branco de duas semanas atrás, aquela que teria aprendido comigo eventualmente se eu tivesse dado a ela o mesmo tempo que dei às outras. perder isso não teria parecido perder uma ferramenta. teria parecido perder um relacionamento que eu nem sabia que era permitido manter.

@OpenGradient

$OPG

#OPG

$IN

$AIGENSYN

houve um momento, cerca de seis meses depois, em que percebi que eu não conseguia descrever o que a ferramenta estava fazendo — não o fluxo de trabalho, não a lógica, nem a coisa por baixo. eu havia construído uma parte significativa do meu trabalho em cima de algo que eu não conseguia ver por dentro.

aquilo me incomodou menos do que deveria. os resultados pareciam certos, então eu otimizei para eles e parei de perguntar se estavam certos.

essa distinção, entendi, é a armadilha real. não a dependência da ferramenta. a dependência de confiar nela sem saber por quê.

eu sempre achei que o risco era sobre o fluxo de trabalho. que a ferramenta se tornaria estrutural, que remover isso custaria caro demais, que eu eventualmente não teria escolha a não ser continuar usando. mas não era isso que eu não conseguia aceitar.

a coisa mais difícil de nomear era o que acontece quando você confia em algo tempo suficiente para parar de perceber que está confiando. o seu julgamento vai se ajustando aos resultados dela sem que você decida isso. e um dia os resultados mudam, e você percebe que não tem em que se apoiar, porque nunca entendeu o que os produzia.

esse é o problema ao qual eu voltava quando comecei a ler sobre o que a OpenGradient está construindo. o que ficou comigo não é apenas que você pode mover cargas de trabalho; é que você nunca precisa fazer uma inferência por fé. o registro do que foi executado e do que ele retornou está sempre aí, para ser visto.

eu não tenho uma conclusão clara aqui. mas estou cada vez mais certo de que a pergunta verdadeira não é se você consegue se afastar de uma ferramenta de IA. é se, o tempo todo em que você esteve usando, você realmente sabia em que estava construindo.

@OpenGradient
$OPG
#OPG
$TAC
$GWEI