Queime suas flags: CLIs interativas para agents — Mark Lummus e Navinkumar Patil, PayPal

Autoria: AI Engineer · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Burn Your Flags: Interactive CLIs for Agents — Mark Lummus & Navinkumar Patil, PayPal · Canal: AI Engineer · 53:14 · Assistir no YouTube

Tópicos: Agentes de IA, Ferramentas de desenvolvimento com IA

Resumo

Mark Lummus e Navinkumar Patil apresentam os desafios de usar CLIs interativas em workflows com agents: muitos harnesses não conseguem acompanhar as interações, e a falha pode ocorrer sem aviso. Em um workshop, os participantes adaptam a CLI de pedidos de café PayPal Cafe para funcionar melhor com agents e competir por um Mac Mini. As sugestões incluem usar tmux, criar canais paralelos com saídas estruturadas e fornecer contexto adequado; os palestrantes também destacam que uma CLI determinística é uma ferramenta mais previsível para um LLM.

Pontos-chave

CLIs interativas podem falhar silenciosamente quando o harness não consegue interpretar prompts e mudanças na interface.
Flags funcionam bem em fluxos simples e previsíveis, mas são menos adequadas quando as opções dependem do contexto ou de respostas em tempo real.
Agents podem raciocinar, reagir, perguntar, tentar novamente e percorrer uma árvore de decisões.
Acessibilidade oferece um modelo para adaptar interfaces a uma nova categoria de usuários: os agents.
O workshop propõe adaptar a CLI PayPal Cafe para que agents consigam fazer pedidos de café.
tmux pode manter sessões e tarefas de longa duração acessíveis, além de permitir capturar a saída do terminal.
Canais paralelos com dados estruturados, como JSON, podem oferecer aos agents uma interface mais legível por máquina.
Fornecer contexto sobre o ambiente e as restrições ajuda o agent a tomar decisões mais adequadas.
Uma CLI determinística torna os resultados mais previsíveis para um LLM, que é a parte não determinística do sistema.
Entre as sugestões finais estão fornecer bom contexto, criar um canal paralelo e usar tmux.

Capítulos

Início	Capítulo	Resumo
00:12	Apresentação e objetivo do workshop	Os palestrantes introduzem o tema das CLIs interativas e explicam que o público poderá participar de um exercício prático.
02:18	Por que CLIs interativas desafiam os agents	Os harnesses podem não acompanhar prompts interativos, causando falhas silenciosas, enquanto flags têm limites em fluxos contextuais.
05:02	Agents, árvores de decisão e acessibilidade	Os palestrantes contrastam agents com scripts de automação e propõem a acessibilidade como referência para projetar interfaces para agents.
06:40	O desafio PayPal Cafe	O público recebe o desafio de adaptar a CLI Bris Barista 9000 para agents, com um Mac Mini como prêmio.
08:14	Contexto das CLIs e início do exercício	Navinkumar Patil relembra a evolução das ferramentas de desenvolvimento e apresenta o repositório PayPal Cafe e as regras do workshop.
15:52	Modelos e orçamento de tokens	Os palestrantes propõem testar se modelos mais rápidos e econômicos conseguem usar a CLI sem depender de modelos de alto desempenho.
25:44	Primeira sugestão: usar tmux	O uso de tmux, do comando help e da captura de painéis é apresentado como maneira de facilitar a interação dos agents com a CLI.
28:20	Canais paralelos e saídas estruturadas	A apresentação recomenda oferecer aos agents um canal paralelo com dados estruturados, em vez de depender apenas da leitura visual do terminal.
31:25	Contexto para diferentes tipos de usuário	Os palestrantes explicam como fornecer contexto sobre o ambiente e as restrições para que o agent possa orientar o pedido.
34:14	Placar e critérios do desafio	A equipe acompanha as pontuações e esclarece que o desempate deve considerar o tempo de resposta.
39:52	Ideias do público e CLI determinística	Um participante descreve uma solução baseada em parser determinístico, e Mark defende que a CLI seja previsível para o LLM.
46:11	Relatos dos participantes	Os vencedores contam como usaram agents, Claude Agent SDK e automação para criar e otimizar suas soluções.
51:36	Conclusões e entrega do prêmio	Os palestrantes resumem as recomendações de contexto, canais paralelos e tmux, encerram o workshop e anunciam o vencedor.

Citações

Um agent pode percorrer uma árvore de decisões, se você fornecer uma. — 05:34

Queremos que a CLI seja determinística. O LLM é a parte não determinística. — 41:59

Dê um bom contexto, forneça um canal paralelo e diga para usar tmux. — 52:06

Conceitos e entidades

Interactive CLI (conceito): Interface de linha de comando que apresenta prompts e adapta as próximas perguntas conforme as respostas ou o contexto.
PayPal Cafe (repo): Repositório do exercício, que contém uma CLI de pedidos de café para os participantes adaptarem.
Bris Barista 9000 (ferramenta): CLI de demonstração que recebe pedidos de café e apresenta dificuldades quando usada por um agent.
tmux (ferramenta): Multiplexador de terminal citado como forma de manter sessões, dividir painéis e capturar a saída da CLI.
PayPal (empresa): Empresa onde os palestrantes trabalham e que está associada ao repositório PayPal Cafe.
Mark Lummus (pessoa): Palestrante apresentado como responsável por ferramentas para desenvolvedores na PayPal.
Navinkumar Patil (pessoa): Palestrante apresentado como líder técnico da equipe de ferramentas para desenvolvedores.
Claude Agent SDK (ferramenta): SDK mencionado por um participante como base do agent usado para construir e executar uma solução determinística.

Tradução completa (pt-BR)

00:12 Olá a todos, sejam bem-vindos. Meu nome é Mark Lumus. Sou chefe de ferramentas para desenvolvedores na PayPal. Comigo está Naveen Kumar. Ele é nosso líder técnico da equipe de ferramentas para desenvolvedores. Hoje vamos falar um pouco sobre CLI. O título da nossa apresentação pretende ser um pouco provocador, e vocês vão entender por quê no fim da apresentação.

00:43 Hoje vamos falar um pouco sobre um tipo específico de CLI: a CLI interativa. Vamos propor um exercício e oferecer a vocês — para quem quiser participar, afinal, isto é uma oficina — uma CLI que vocês podem melhorar para funcionar em um workflow com agents. Esse é o objetivo da oficina de hoje. Então, vamos

01:14 dar bastante tempo a vocês. Vamos conversar por alguns minutos. Vamos tentar falar o mínimo possível e depois vocês poderão começar. É interessante. Acho que alguém disse que o velho virou novidade. Quando comecei minha carreira, há muito tempo — já tenho cabelos grisalhos —, tudo era uma CLI. Tudo era uma interface de linha de comando. Alguém se lembra de trabalhar com MS-DOS antes de termos o Microsoft Windows? Isso mesmo. Meu

01:46 primeiro emprego depois da faculdade foi projetando sistemas embarcados. Você se conectava a um computador por uma porta serial, abria um terminal compatível com VT100 e começava a digitar. Essa era sua CLI. Era a maneira de interagir com o computador. Hoje, as CLIs voltaram a ganhar força, acho, talvez com o Claude Code, que realmente as tornou muito mais

02:18 populares. E agora temos o Codex, então muita gente está adicionando ferramentas de CLI para facilitar o acesso às funcionalidades que quer disponibilizar para um agent. No caso das CLIs interativas, que é o motivo de estarmos aqui hoje e o que queremos discutir, os agents recorrem ao Bash constantemente, e isso é bom. Mas, se executarem uma CLI interativa,

02:50 isso pode ser ruim, porque nem todos os harnesses lidam muito bem com interação. E, se não lidarem bem, vão falhar em silêncio. Você não vai saber. Sem erros, sem nada. Mas por que isso importa? As CLIs interativas são ótimas porque a próxima pergunta pode surgir dependendo da sua resposta à pergunta anterior. O número de sinalizadores aumenta se você tentar criar

03:22 sinalizadores que prevejam todos os fluxos possíveis. As escolhas dependem do contexto e também podem responder ao que está acontecendo em um ambiente. Se sua CLI chama uma API e recebe uma resposta, e então a pergunta que aparece depende do que a API retorna, é muito, muito difícil lidar com isso usando sinalizadores; e as proteções podem estar no fluxo interativo.

03:55 Aqui à esquerda temos um exemplo. Vemos uma CLI de demonstração. Ela é interativa. A CLI abriu um prompt interativo, um prompt de chave de erro. A pessoa consegue vê-lo. Ela pode usar as setas do teclado, mas o agent não o vê. O agent vê um ciclo de redesenho, não uma pergunta, e o harness perde o estado da interface.

04:26 Esse é o modo de falha. Ele é silencioso e invisível. A solução mais comum é simplesmente adicionar sinalizadores. E sinalizadores funcionam bem para casos de uso simples. Você sabe de antemão quais são os fluxos. É uma única passagem. Todas as opções são independentes. Ótimo, ótimo caso de uso para um sinalizador simples.

05:02 Mas, quando as respostas mudam de acordo com o contexto ou com as reações a eventos em tempo real, é aí que isso se torna um problema. Você realmente não pode usar sinalizadores nessas situações. Um agent não é como um script de automação. Um script de automação não sabe nada. Todas as decisões são definidas de antemão. O agent consegue raciocinar. Consegue

05:34 reagir. Consegue perguntar. Consegue tentar de novo. Consegue voltar atrás. E, o mais importante, um agent consegue percorrer uma árvore de decisão, se você fornecer uma. Não dá para fazer isso com sinalizadores. Já temos um modelo para o que está acontecendo aqui. Ele se chama acessibilidade. Então, se vocês mapearem o que fazemos para as pessoas

06:06 para o que precisamos fazer para os agents, as soluções ficam claras. É a mesma disciplina, com um novo leitor. Então, este é o desafio: como podemos manter as proteções e as orientações sem fingir que agents e pessoas têm as mesmas capacidades? Não vou responder a essa pergunta. Esse é justamente o objetivo desta oficina.

06:40 Então, este é o desafio. Temos uma CLI. Nós a chamamos de Bris Barista 9000. Ela vai receber pedidos de café e vai falhar quando vocês tentarem executá-la a partir de um agent, porque é interativa. E, se vocês decidirem participar do desafio, o vencedor ganhará um Mac Mini.

07:12 Vocês podem levá-lo hoje. Está bem naquela sacola. [risos] >> Conseguir um Mac Mini foi um desafio por si só. Vou ser sincero. Certo. Agora, [limpa a garganta] regras simples. Vamos fornecer uma CLI. Vocês fazem alterações nela, executam-na por meio de um agent, e ela vai enviar algumas informações

07:42 para o nosso servidor. Depois, vai atualizar um placar. Vamos exibir o placar daqui a pouco. Não temos duas entradas, então vamos trocar os slides pelo placar para que vocês possam vê-lo. Agora, aqui está Naveen. Ele vai explicar tudo para vocês. >> Obrigado, Mark. Certo. >> Legal. Sim. Acho que é uma tarefa empolgante para todos, e esse tópico

08:14 é muito importante para mim, mas, deixando isso de lado, Mark, vamos tomar um café depois de construir isso? [risos] >> Espero que sim, se tivermos sucesso. >> Certo, legal. Então, antes de começarmos a tarefa, quero levá-los por uma jornada. Quando comecei minha carreira de engenharia, comecei a experimentar IDEs. Comecei a usar o Eclipse porque trabalhava principalmente com Java.

08:45 Com o tempo, passei para o IntelliJ, da JetBrains. Foi incrível. Olhando para trás, há cinco ou seis anos, as coisas começaram a evoluir. Surgiram novos IDEs no mercado, especialmente o Microsoft VS Code, que deu origem a muitos outros IDEs também. Se olharmos para o cenário atual, a Microsoft tinha seu próprio editor VS Code, mas, mais tarde, novos

09:18 IDEs de IA começaram a surgir, como Cursor e Windsurf, para citar alguns. Em toda essa jornada, as CLIs permaneceram constantes, certo? Em certo momento, pensei: “Bom, sabe, as CLIs estão desaparecendo aos poucos. Talvez não voltem.” Mas, sabe, gosto de lembrar aquela fala do filme Se Beber, Não Case: os quatro amigos estão no carro e dizem: “Ei, nós estamos

09:49 de volta”. Imaginem a CLI dizendo isso uma para a outra. E, no mundo da IA, elas são mesmo muito valorizadas, certo? Quem comprou, sim, não sei. Mas a história toda é que agora as CLIs mudaram. E quem é responsável por isso? Os agents, certo? Então, esta oficina tem como foco principal os agents e suas CLIs. E será um exercício prático.

10:19 Há regras. Não há regras. Então, sintam-se à vontade para hackear o máximo possível; e o prêmio está aqui. Então, talvez… Ven, você pode me passar o laptop? Temos algumas coisas. Então, temos o repo PayPal cafe. Ele contém a CLI que vocês podem baixar. Essa é a CLI básica. Agora, não vai ser

10:52 tão fácil ganhar um Mac Mini. É. Vocês receberão alguns comandos iniciais. Brinquem com eles. Façam seu cadastro. Informem um nome de usuário, o que quiserem. Um apelido, qualquer coisa, e tentem preparar um café com isso. Certo, esse é o objetivo. E, durante todo esse exercício, queremos que vocês também sejam inovadores nas abordagens. Daqui para a frente, vai ficar

11:22 interessante usar agents com a CLI. Então, pensem nisso por essa perspectiva. Vou trocar isso. Acabei de trocar meu laptop aqui. Durante a sessão, não vamos começar dando dicas. Quando acharmos que gente suficiente instalou o repo e consegue executar a CLI como está, talvez a cada 15

11:56 ou 20 minutos, vamos compartilhar uma boa ideia. Não vou chamá-la de melhor prática. Vou chamá-la apenas de boa ideia, porque sinto que ainda estamos no começo dessa jornada e não sabemos quais são as melhores práticas. Estamos tentando descobri-las agora. São boas ideias. Também espero que, no final, ouçamos algumas ótimas ideias de vocês na plateia, para podermos

12:27 compartilhar. Então, tenham isso em mente. Estamos todos aprendendo. Esta é uma jornada. Voltaremos a isso mais perto do final. Não está funcionando? Deem-nos alguns minutos. Acho que vamos resolver os problemas técnicos.

13:13 Parece que as pessoas estão realmente usando. Então, no lado direito, vocês verão “get CLI” e, se acessarem PayPal cafe/rules, encontrarão todas as regras descritas. Sintam-se à vontade para começar a trabalhar na CLI enquanto resolvemos isso. Certo.

13:53 >> Temos a Europa? Ah, é aquele? >> Sim. Ei, aí está. >> Legal. >> Ótimo. >> Obrigado. Muito obrigado. Ei.

14:26 Legal. Então, vocês podem ver que… Ah, estamos vendo algumas inscrições. Certo. No lado direito, vocês verão “get CLI”. Podem baixar isso. Espero que consigam ver: fica no canto inferior direito. E há algumas regras aqui. Vocês podem clicar nessas regras, e elas vão aparecer.

15:00 Então, provavelmente vamos levar uns 25 a 30 minutos. Nesse meio-tempo, vamos interromper com mais slides para deixar tudo interessante. [risos] >> Onde está o laptop dos outros slides? O Venode está com ele. Certo, tudo bem. Estamos aqui para ajudar. Se estiverem com algum problema, levantem a mão. Vamos tentar ajudar da melhor forma possível.

15:52 Um pouco sobre os modelos. Não usem modelos. Tivemos um pequeno debate interno. Existem ótimos modelos por aí. O interessante sobre este desafio

16:22 é que, se vocês usarem o modo de raciocínio mais avançado nos LLMs de ponta, provavelmente conseguirão resolver isso na força bruta. Mas sinto que, no cenário atual, as equipes estão começando a pensar no orçamento de tokens. Então, não necessariamente queremos desperdiçar tokens de raciocínio de alto nível executando uma ferramenta de CLI. Portanto, o verdadeiro

16:52 desafio é: vocês conseguem fazer o Haiku, o Sonnet ou algo nesse nível executar a CLI? Sabemos que conseguem fazer isso com os modelos mais avançados. Conseguem fazer com algo intermediário, que seja mais rápido e mais barato? Esse é o desafio interessante, se quiserem encará-lo. >> Parece divertido. >> Sim. >> Ótimo.

17:56 Já que estamos falando de café, Mark, você sabia que São Francisco tem as melhores padarias dos Estados Unidos inteiros? Sabia disso? >> Não sabia. >> Pois é, você deveria mesmo… >> Pode continuar. Sim, continue, conte mais. >> Já fiz alguns roteiros por padarias pela cidade, e são muito divertidos. Você deveria conhecer todas as padarias incríveis daqui. >> Certo. >> Sim. Tem alguma favorita? Butter and Crumble.

18:30 A minha favorita. Embora eu não tenha conseguido ir até lá. [risos] Ótimo. Então, por enquanto, J Gray Codex está no topo. Pessoal, tentem alcançá-lo, seja ele ou ela.

21:03 Com o comando init, vocês podem registrar seus nomes. Espero que alguns de vocês já tenham descoberto isso.

22:06 Quer falar sobre a primeira…

22:45 Talvez você precise pensar em…

24:47 Quando eu conectar, eu…

25:44 >> [suspira] >> Pode continuar. >> Certo. >> Legal. Vamos passar para algumas apresentações. Enquanto isso, vocês podem começar a trabalhar. Quer dizer, podem continuar trabalhando com a CLI que têm. Mas, como primeira dica, é uma boa ideia começar a usar o tmux. Quantos de vocês conhecem o tmux? Certo, uma boa parte da plateia. Então…

26:16 sim, resumindo: comecem executando o tmux e, em seguida, usem o comando help. O help é muito importante, porque todo agent de IA de hoje depende do comando help antes mesmo de começar a usar aquele comando. [risos] Então, send-keys e capture-pane levam vocês

26:48 longe. Para quem não conhece, o tmux permite usar várias sessões de terminal, e tem um recurso de painel dividido que vocês podem aproveitar. Neste exemplo, dá para ver aqui… A tela está muito pequena para mim. Vou aumentar um pouco o zoom. Isso. tmux -D. O que essa

27:19 flag faz é desconectar toda a CLI e colocá-la em outra instância do tmux. [risos] Vocês podem ver o tamanho. Como eu disse, o tmux tem painéis divididos. Assim, vocês podem trabalhar com a CLI e… Essa é uma daquelas funcionalidades legais que podem ajudar os agents a executar muitas atividades.

27:50 Pensem nisso quando quiserem executar vários agents. Vocês podem iniciar sessões diferentes, e o tmux mantém um registro dessas coisas: ele sabe no que vocês estão trabalhando e retoma as sessões sempre que necessário. Isso realmente ajuda os agents a

28:20 se comunicarem quando há várias sessões abertas. E vocês podem executar tarefas longas dentro do tmux. [fungada] A segunda boa ideia são os canais laterais de IPC. Como mencionei antes, o tmux foi uma boa evolução. Então, em vez de fazer captura de tela, que o tmux usa para inferência visual, [risos]

28:51 vocês podem começar a usar canais laterais. Os canais laterais ajudam a definir as teclas de seta que vocês têm e a entender… Vou explicar como isso funciona no próximo slide. Mas o agent precisa saber qual é o JSON de saída. Isso é fundamental nesta apresentação: os JSONs de saída. Os agents precisam deles, já que agora temos várias personas. Antes, costumávamos

29:22 atender apenas às pessoas; agora temos agents. Então, pensem nas duas personas, para que a CLI possa atender a ambos os casos de uso. Para quem não conhece os canais laterais, vou explicar em termos simples: pensem neles como a adição de uma REST API à aplicação web. O site oferece às pessoas uma interface visual.

29:52 A API oferece uma interface estruturada para máquinas. Então, pensem nos canais laterais exatamente da mesma forma. Essa é uma analogia que posso usar: ler o estado e enviar entradas como dados. Temos o comando barista brew –agent. Esse comando permite executar a CLI com agents em segundo plano, certo?

30:24 Vocês querem que os agents sejam executados em segundo plano e, ao inserir todos esses comandos, eles vão ajudar vocês a experimentar isso na CLI que estão usando agora. Vejam se conseguem avançar na aplicação de cafeteria que está nos laptops de vocês. Há algumas coisas que vocês podem fornecer como exemplo aqui. Dá para ver barista brew ask e, em seguida,

30:55 há várias informações. Ah, o que é isso? Certo: campos, depois pequeno, grande, médio, talvez os tamanhos do café; e o padrão é grande. O que isso quer dizer? São dados de entrada, certo? Então, tudo o que vocês precisam fazer é fornecer esses dados de entrada para que o agent saiba disso. E precisam fazer isso em formatos legíveis por máquina. É aqui que essa ideia entra em cena.

31:25 Então, não digam ao agent apenas o que a pessoa vê, certo? Pensem fora da caixa. O que os agents vão pensar? Eles têm conjuntos de habilidades diferentes, e vocês precisam começar a aproveitar essas habilidades. O mesmo prompt com um cérebro diferente. Então, no lado esquerdo, vocês veem que eu estava falando de personas diferentes. Uma são as pessoas, e a outra são os agents.

31:57 A CLI é a mesma, mas, quando você olha para a forma como ela é estruturada, os seres humanos querem um conjunto de opções. Por outro lado, você tem agents aos quais poderia fornecer todas essas informações em um único arquivo de entrada. [fungada] Certo. Então é aqui que entra o que chamamos de injeção de contexto. Você fornece o contexto de uma forma que… deixa eu dar um exemplo. Você está, na verdade,

32:29 com pouco leite de aveia. Certo. E você só tem dois galões de leite de aveia. Diga ao seu agent que tipo de informação ele precisa pedir ao usuário. Confirme se duas onças são suficientes. Quer que eu escolha uma alternativa para você? Essas informações devem ser fornecidas usando a injeção de contexto como técnica, e você pode aproveitar isso

33:00 na CLI que está construindo. Experimente usá-la. Talvez você fique no topo do placar. Então, começamos uma jornada com o T-Max, que basicamente faz captura de tela, até a injeção de skills. O T-Max exige pouco esforço. Acho que muitos de vocês talvez já tenham experimentado. Mas é aqui que os canais laterais [fungada] também vão ajudar a fornecer [limpa a garganta]

33:32 um bom tipo de feedback aos seus agents, e a injeção de contexto vai oferecer diferentes cenários nos quais vocês podem pensar, que não acontecem no caso humano. Então, sim, continuem tentando melhorar suas pontuações. Quer mostrar isso? >> Sim.

34:14 Leva um tempinho. >> Aí está. >> Certo, [fungada] legal. Estamos vendo bastante atividade por aqui. [limpa a garganta] [risos] Ah, alguém está bem perto de 5.000. É bank? Certo. [limpa a garganta]

34:53 Alguma pergunta até agora? Alguém quer uma resposta? Alguma dúvida? >> Desculpe. >> [risos] >> Certo, vou repetir a pergunta. [limpa a garganta] O que acontece se várias pessoas chegarem à pontuação de 5.000? Mark, quer responder? >> A ideia era olhar a pontuação e, se houvesse empate, olharíamos

35:25 quem levou menos tempo. Agora, com base no que estou vendo, há várias pessoas que concluíram três de três em zero segundos. Vejo [risos] um monte de gente que concluiu em zero segundos. Então, preciso consultar alguém, porque isso não deveria ser possível. Mas a ideia é que primeiro olharíamos a pontuação mais alta e

35:58 depois o tempo de resposta. Assim, uma resposta correta retornada rapidamente teria prioridade sobre uma resposta correta retornada lentamente. Então, por enquanto, só temos uma pessoa.

36:29 >> Certo, desculpe. >> Só temos uma pessoa. No fim, isso chega ao fim do placar. Nicholas [fungada], acabou o jogo. [limpa a garganta]

37:09 Zero segundos. Você quer

37:41 esperar mais dois minutos? Podemos abrir espaço para ideias e ver o quanto eles estão engajados. Tivemos

38:23 >> [limpa a garganta] >> Daqui a poucos minutos, vamos abrir espaço para compartilhar ideias. Então, espero que ouçamos algumas ideias ótimas, que vão além das nossas boas ideias, porque sei que há algumas por aí.

38:58 Mark, você esperava que tantas pessoas chegassem aos 4.000? >> Sim, com certeza. >> Nesta conferência? >> Com certeza. >> Ótimo. Você não esperava? >> Não, esperava, sim. [risos]

39:52 O que você acha? Alguém consegue chegar aos 5.000? >> Não sei. Vamos deixar aberto. [risos] >> Por que não abrimos espaço para as pessoas falarem agora? >> Sim, claro. Adoraríamos ouvir ideias. Alguém na sala teve outras ideias que ajudaram a chegar a uma pontuação tão alta tão rápido? Ninguém quer sair da mesa.

40:24 [risos] Ah, temos alguém. Sim. Deixa eu ir até você

40:55 [limpa a garganta], porque mal consigo ouvir você. >> Certo. É muito fácil manipular esse benchmark, porque a única coisa que importa é concluir um pedido com uma latência muito, muito baixa. Então, se você fizer um analisador determinístico… isso vai contra completamente o espírito deste desafio, mas, se fizer um analisador determinístico

41:26 e tiver algo bem perto do servidor, dá para reduzir a latência muito rápido se você simplesmente testar todas as possibilidades. >> Certo. Foi isso que você fez? >> É o que estou fazendo agora. >> Certo. Tudo bem. Você mencionou algo interessante: o analisador determinístico que está rodando na sua CLI. Certo. Na verdade, gosto da ideia de determinismo na CLI. E [limpa a garganta] o motivo é que

41:59 se a CLI é uma ferramenta para ser usada por um LLM, então você definitivamente quer que ela seja determinística. O LLM é o elemento não determinístico aqui. Queremos que a CLI seja, como alguém descreveu, um instrumento pequeno e afiado. Ela deve ser muito, muito focada no que faz. E, sempre que você der um comando, quer que ela retorne a mesma resposta. Então,

42:31 você não quer criar um agent dentro da CLI e depois entregar essa CLI a outro agent, porque não sabe o que vai obter. Mais alguma ideia interessante? Obviamente, muita gente descobriu como manipular o sistema. >> [risos] >> Onde há um Mac Mini, há um jeito, pelo visto. >> Sim. [risos]

43:16 Esperem cinco minutos. Cinco minutos. A pontuação não muda há um tempo, antes de o site cair. >> Você atualizou a página?

43:57 >> [tosse] [limpa a garganta]

44:41 >> Por que está dizendo que está reconectando? Ah, voltou. Certo. Vejam, a rede está um pouco lenta. A rede está um pouco lenta por aqui. >> Muitos, muitos computadores. Parece bom. Caiu.

45:35 E agora travamos. [limpa a garganta] Lá vamos nós. Nenhuma mudança nos resultados. Certo.

46:11 Queremos esperar mais alguns minutos ou encerrar? >> Sim, cinco minutos. >> Cinco minutos. Certo. Quer trazer o PPD para o PPD para as alegações finais? >> Vamos dar mais ou menos cinco minutos. >> Sim. >> E depois encerramos. >> Cadê o Bon? Cadê o Bonk? Levante a mão. >> Quem é Bon? Certo, temos alguém. >> Muito bem. Sorriso grande. Sorriso grande. [risos]

46:44 Agora, >> queremos saber como você fez isso. Então, quando encerrarmos, vamos deixar você explicar o que fez. Adoraria ouvir. [risos]

47:15 Preciso ir até ali. >> Sim, >> espera aí. Desculpe. Eu devia ter pedido outro microfone para a sala, para as perguntas. >> É, então. Bonk é só uma coisa de agent criada sobre o Cloud Agent SDK. Ele construiu tudo. Antes disso, eu já tinha uma espécie de skill de eval bench que cria um

47:45 ambiente e otimiza. Então, basicamente, acabou criando um solucionador determinístico de CLI e agora está rodando no T-m, fazendo chamadas incessantes às suas APIs. >> Certo. >> Sim. >> Tudo bem. Também acho que tive sorte, porque em certo momento consegui 29 milissegundos. Provavelmente porque estamos na mesma região. >> Certo. >> É só a latência da rede, >> certo? E tudo isso foi feito com o claude >> com o Claude Agent SDK. Certo. Só controlando tudo pelo Slack.

48:16 >> Não, qual modelo? >> Opus 4.8. >> Certo. >> Sim. >> Você tentou com outros modelos? >> Para a implementação, para criar a CLI, ou >> para o seu agent? Como faríamos isso? A CLI é completamente determinística. Claro. Claro. Então, o agent criou a CLI e agora está só executando-a no T-Max. >> Certo. >> Sim. >> Ótimo. >> Sim. >> Parabéns.

48:46 >> Vamos para a próxima pessoa. Danny. Quem é Danny aqui? Você vê a última pessoa. [limpa a garganta] O que queremos saber? >> Sim. Como você criou isso? >> Sim. Então, não sei nada sobre

49:19 programação. Estou… sou basicamente um vibe coder. Tenho alguns agents e simplesmente disse: “Ei, aqui está o problema. Leia e depois conserte, conserte.” Então, eu só… Sim. Estou com o Cloud Code aberto no VSC. >> Você já tinha criado uma CLI antes? >> Não. Vi há algumas horas que, obviamente, havia um prêmio para ganhar. Então, entrei e disse: “Ei, [risos] descubra isso. Explique para mim como se eu, sabe, não soubesse nada.” E depois explique como se eu fosse

49:51 cinco. É. Eu, eu, eu não sei. Então, e aí tivemos, é, sim, tivemos alguns bons resultados, e eu disse: “Ei, precisamos deixar isso mais rápido. Me dê algumas sugestões e, sim, falando sério.” Então, eu, eu acho [fungada] que temos dois scripts rodando, e o primeiro chegou a 49,98. Aí eu disse: “Ei, faça uma cópia e me dê algumas sugestões de como podemos chegar a 49,99.” >> Certo. >> Você recebeu alguma sugestão? É…

50:22 Esse agent é bem automatizado. Então, eu só digo algo como: “Ei, aqui está o início, aqui está o fim. Faça algumas perguntas no começo, se precisar, mas depois corrija os problemas, para eu não ter que lidar com isso”, esse tipo de coisa. Então, desculpe, não foi uma resposta muito boa… >> Não, foi boa. Tenho certeza de que muita gente está se perguntando: escrever uma CLI é algo que você faria ou pediria ao seu agent para fazer? Claramente, temos muitas pessoas na…

50:54 sala que vão apontar o Claude ou o Codex para isso e dizer: “Crie uma CLI, deixe-a rápida, deixe-a determinística.” E essas são as três ideias, certo? Certo. Quer mudar o slide?

51:36 Aí está. >> [limpa a garganta] >> Então, falamos sobre todas as nossas sugestões. Ouvimos algumas ideias. A ideia predominante foi deixar o agent descobrir isso por você. Adoro essa ideia.

52:06 É, mais alguma coisa antes de encerrarmos? Certo, aí está. O que levamos daqui, com base nas nossas instruções e recomendações: dê a ele um bom contexto, forneça um canal secundário e diga para usar o tmux. Essas são três boas ideias para começar. Obrigado a todos.

52:37 Bonk, quer vir aqui? [aplausos] >> Monk ainda é o vencedor, certo? Sim. Certo. Não, não, já decidimos. Decidimos há cinco minutos. >> Certo. >> Sim. Sim. Não vou mudar [limpa a garganta], não vou mudar. >> Sim. >> Nós, nós já decidimos. >> Ótimo. [aplausos] >> Vamos… [limpa a garganta] Vamos tirar uma foto, >> sabe, para as redes sociais. Isso mesmo.

53:14 É um Mac Mini de verdade. >> É um Mac de verdade. Meu Deus, eles existem. [risos] >> Certo, ótimo. >> De onde veio? >> [música]

Transcrição original

[00:12] Hi everyone, welcome in. My name is Mark Lumus. I’m head of developer tools at PayPal. With me I have Naveen Kumar. He’s our tech lead for the developer tools team. And today we’re going to talk to you a little bit about CLI. The title of our presentation is meant to be a little provocative and you’ll understand why at the end of the presentation.

[00:43] So today we’re going to talk a little bit about a specific kind of CLI, interactive CLI, and we’re going to set up an exercise and we’re going to give you for those of you who wish to participate, this is a workshop after all. We’ll give you a CLI that you can make work better in an Agentic workflow. So that’s the purpose of this workshop today. So we’re going

[01:14] to give you plenty of time. We’ll talk for a few minutes. Try to keep the talking to a minimum and then we’ll get you started. Now it’s kind of interesting. I think someone said what’s old is new. When I started my career long time ago, I have gray hair. Everything was a CLI. Everything was a command line interface. Any of you remember working with MS DOSs before we had Microsoft Windows? There you go. My

[01:46] first job out of college, I was designing embedded systems. And so you would connect to a computer over a serial port and you would pull up a VT100 compatible terminal and you would start typing. And that was your CLI. That was the the the way you interfaced with the computer. So with today CLIs have kind of had a resurgence I guess you know with the maybe it was clawed code that really made them much more

[02:18] popular and now we have codecs um and so a lot of people are are adding CLI uh tools so that it’s easier to access the capabilities that they want to expose to an agent. Now, with interactive CLI, this is why we’re here today with what we want to talk about. Um, agents shell out to Bash constantly, and that’s good. But if they run an interactive CLI,

[02:50] that may be bad because not all harnesses handle interaction very well. And if they don’t handle it very well, they’ll fail quietly. You won’t know. No errors, no nothing. But why do we care? Interactive CLIs are great because the next question can emerge based on what way you answer a previous question. Flags multiply if you try to create

[03:22] flags that predict all the possible flows. The choices are contextual and they can also be responsive to what’s happening in an environment. So if your CLI is calling an API and getting a response and then the question comes up based on what the API returns, that’s really really challenging to handle with flags and the guard rails can live in the interactive flow.

[03:55] So here’s an example over here on the on the left. We see a a sample CLI. It’s interactive. The CLI’s opened an interactive prompt, an error key prompt. The human sees it. The human can use the arrow keys, but the agent doesn’t see it. The agent sees a redraw loop, not a question. and the harness loses the UI

[04:26] state. So here’s the failure mode. It’s silent and invisible. So the common fix will just add flags. And flags are fine for simple use cases. You have uh you know what the you know what the flows are up front. It’s a single pass. All the options are independent. Great great use case for a a a simple flag.

[05:02] But when the answers change based on the context or they’re changing based on reactions to real time events, that’s when it becomes a problem. You really can’t use flags for those situations. Now, an agent is not like an automation script. An automation script knows nothing. All of the decisions are pre-baked up front. The agent can reason. It can

[05:34] react. It can ask. It can retry. It can back up. And most importantly, an agent can walk a decision tree if you provide provide one. You can’t do that with flags. So we already have a model today for what’s happening here. It’s called accessibility. And so if you map what we do for humans

[06:06] to what we need to do for agents, then the solutions become apparent. It’s the same discipline with a new reader. So here’s the here’s the challenge. How might we keep the guard rails and the guidance and stop pretending that agents and humans have the same abilities? Now, I’m not going to answer this question. That’s the whole purpose of this workshop.

[06:40] So, here’s the challenge. We’ve got a CLI. We call it Bris Barista 9000. It’s going to take coffee orders and it’s going to fail when you try to run it from an agent because it’s interactive. And if you choose to participate in the challenge, the winner will win a Mac Mini.

[07:12] Walk walk away with it today. It’s in that bag right there. [laughter] >> That was a challenge in and of itself getting a Mac Mini. I’ll be straight up. Okay. Now, [clears throat] simple rules. We’re going to give you a CLI. You make changes to that CLI, run it through an agent, and it’s going to send some information

[07:42] up to our server. And then it’s going to update a leaderboard. And we’ll put put the leaderboard up in a moment. We don’t have two inputs, so we’re going to change the slide deck out for the leaderboard so you can see it. Now, here’s Naveen. He’s going to talk you through this. >> Thank you, Mark. All right. >> Cool. Yeah. Uh I think it’s an exciting assignment for everybody and this topic

[08:14] is very near and dear to me but uh keeping things aside Mark are we getting any coffee after we build this [laughter] >> I hope so if we’re successful >> okay cool so yeah let me uh before we start into um the assignment I want to take to a journey right uh when I started my engineering career I started to play with ids. I started to use Eclipse because I was primarily using Java.

[08:45] And as time went by, moved into Intelligj uh Jet Brains. It was amazing. Looking back, five or six years behind uh things started to evolve. there were new ids in the market especially Microsoft VS code which gave birth to a lot of u other ids as well. So if you look right now Microsoft had its own VS code editor but later on new

[09:18] AI id started to pop out like cursor windsurf to name a few. In all these journeys, CLIs were constant, right? At some point, I thought, okay, you know, CLIs are having a slow death of their own. Maybe they are not going to come back. But, you know, uh I I I actually like to see this hangover movie dialogue that um you know, all all the four friends are in the car and they say, “Hey, we are

[09:49] back.” Imagine CLI seeing that to each other. And in the world of AI, they are actually VC, right? Whoever bought it, yeah, I don’t know. But the whole story is now the CLI have changed. And who is responsible for that? Agents, right? So this workshop is primarily focusing on agents, your CLIs. And this is going to be a hands-on exercise.

[10:19] There are rules to it. There are no rules to it. So feel free to hack as much as possible and you know the prize is here. Um so yeah we have maybe uh ven if I can get the laptop. So we have couple of things. So we have yeah um so we have the repo which is PayPal cafe. It has the CLI that you can actually download. That’s the barebone CLI. Now, it’s not going to

[10:52] be that easy uh for a Mac Mini. Yeah. Uh so, you will get some initial commands with it. Uh play around with it. Register yourself. Uh provide your username, whatever you like. Um your nicknames, anything, and try to brew a coffee out of it. Okay, that’s that’s the goal. And in this whole exercise, we want you to also be innovative in your approaches and going forward, it’s going to get

[11:22] interesting with agents using the CLI. So think it from that perspective. I change this. I just change my laptops here. Now during the during the session, we’re we’re not starting you out with any hints. Once we feel like enough people have gotten the the repo installed, can run the the CLI as is, then maybe every 15

[11:56] or 20 minutes, we’ll share a good idea. Now, I’m not going to call it a best practice. I’m just going to call it a good idea because I feel like we’re early enough in the journey here where we don’t know what the best practices are. We’re kind of feeling them out now. They’re good ideas. I’m also hoping that at the end we’ll hear some great ideas from you in the audience so we can

[12:27] share. So just keep that in mind. We’re we’re all learning. This is a journey. We’ll come back to that towards the end. Is it not working? Give us a couple of minutes. I think we’ll get the technical issues resolved.

[13:13] seems like people are actually using it. So on the right side you will actually see get CLI and um if you see PayPal cafe/ rules that’s where you will have all the rules outlined to it. Feel free to start working on the CLI till we figure it out. Okay.

[13:53] >> Do we have the Europe? Oh, is it that one? >> Yeah. Hey, there you go. >> Nice. >> Awesome. >> Thank you. Thank you so much. Hey

[14:26] Cool. So you can see this is Oh, we do see some signings. Okay. So on the right side you will see get CLI. You can download that and I hope you guys can see it. It’s at the bottom right. And there are some rules here. You can click on these rules and it will pop out some rules.

[15:00] So, we’ll probably take around about 25 to 30 minutes. Um, and in between we’ll interrupt with more slides and make it interesting. [laughter] >> Where’s the laptop for the other slides? Venode’s got it. Okay, that’s fine. and we’re here to help. If you’re having trouble, please raise your hand. We’ll try to assist you as best we can.

[15:52] a little bit about the models. Don’t use models. Now, we had a little bit of a debate internally. There are some great models out there. The interesting thing about this challenge,

[16:22] if you use the highest thinking mode on the bleeding edge LLMs, you can probably brute way brute force your way through this. But I feel like in the current climate, teams are starting to think about their token budget. And so you don’t necessarily want to waste your highinking tokens on running a CLI tool. So the real

[16:52] challenge is can you make Haik coup or sonnet or something at that level run your CLI? We know you can do it with the highest. Can you do it with something that’s somewhere in the middle that’s faster and cheaper? That’s the That’s the interesting challenge if you if you want to take it on. >> Sounds fun. Yeah. >> Awesome.

[17:56] Since we are on the coffee topic, uh Mark, were you aware that San Francisco City has the best bakeries in the entire United States? Were you aware about that fact? >> I was not aware of that. >> Yeah, you should definitely. >> Go on. Yeah. Go on, tell me more. >> Um, I have I’ve done some bakery crawls uh around in the city and they are so fun. Like you should definitely check out all the amazing bakeries out here. >> Okay. >> Yeah. Any favorites? Butter and crumble.

[18:30] My favorite one. Although I couldn’t go there. [laughter] Awesome. So as of now we have J Gray Codex at the top. So guys please catch up with him or her

[21:03] So with the init command, you could actually register your names. I hope some of you have figured that out.

[22:06] Do you want to talk about the first

[22:45] You might have to think about

[24:47] Once I plug it in, I

[25:44] >> [sighs] >> Go ahead. >> Okay, >> cool. Um, let’s move on to some presentations. Meanwhile, you can start working. I mean, you’ll continue working with the CLI that you have. But as as a first hint, you know, it’s it’s a good idea to start using T-Max. How many of you know about T-Max here? Okay, quite a fair amount of audience out here. Um, so

[26:16] yeah u in short start with running T-Max and um start by putting help command. Now, help is really important because every AI agent in today’s world relies on the help command before it even starts using that command. [laughter] So, yeah, send keys and capture pain gets

[26:48] you far. Now, T-Max actually um for those who actually don’t know about it is like a multiple you could actually use multiple terminal sessions uh with the T-Max and it’s like a split pane feature that you could leverage with T-Max. So, with this example, you can see here um I mean the screen is very short for me. So, let me just zoom in a little bit. Yeah, T-Max D. Now, what this

[27:19] flag does is it detaches the entire uh CLI and puts it under a different emox instance all together for [laughter] you. So you could see size uh T-max capture pane like I said you could actually have split panes in T-maxes. So you could actually take care of u working around with um in in the

[27:50] CLI and uh that’s one of those cool features that can help your agents perform lot of activities. Um, think of it when you want to run multiple agents. You could actually spin up different sessions and T-Max actually takes a log of those things where it knows what are you working on and resumes those sessions whenever it’s needed. So, it’s actually helpful for agents to

[28:20] communicate and start communicating when they have multiple sessions open. And these are some long running tasks that you could actually run inside T-Max. [snorts] Second good idea is IPC site channels. So like I mentioned before, T-Max was a good upgrade. So instead of doing screen scraping, which T-Max actually does um for visual in inference, [laughter]

[28:51] you could start using side channels. Now [snorts] site channels would help you define your arrow keys that you have and help you understand and I’ll go in the next slide uh how it works but the agent should know what is the output JSON now this becomes really critical in the entire talk is output JSONs and Asians want that since we have multiple personalities now earlier we used to

[29:22] only cater to human beings now we have agents. So think of both these personas so that your CLI can actually take advantage of both these use cases. So site channel for those who don’t know about it let me explain to you in in simple words think of it like adding a REST API to your web application and the website gives humans a visual interfere uh interface.

[29:52] The API gives you a machine structured interface right so think of side channel as exactly the same that’s one of those analogies that I can refer read state send input as a data [clears throat] so we have the bista brew hyphen agent now this this is a command that will help you run your CLI with background agents, right?

[30:24] Um, you want your agents to be running in the background and uh you put all of these commands, they are going to help you try using it in your current CLI. See if you are able to um make some progress in the barista application that is out there for in your laptops. Now, there are a couple of things that you could actually provide as an example out here. You can see barista [clears throat] brew ask and then

[30:55] there’s a bunch of information out there. Oh, what is it? Okay, fields then small, large, medium, maybe the sizes of the coffee and yeah, default as large. What does that even mean? That’s input data, right? So all you have to do is feed in this input data so that agent actually knows that and you got to do it in machine readable formats. So this is where um that thing comes in play.

[31:25] So don’t just tell the agent what the human sees, okay? Think it out of the box. What are the agents going to think? They have different skill sets and you have to start leveraging those skill sets. Same prompt with a different brain. Now, [clears throat] so on the left side you see I was talking about different personas. One is the human beings and the other one is the agents.

[31:57] The CLI is the same but when you look at the way it is structured human beings want set of options but on the other hand you have agents wherein you could provide all this information in one single input file. [snorts] Okay. So this is where we call this as context injection comes in play. You provide context in such a way that let me take an example. You you are actually

[32:29] low on oat milk. Okay. And uh you have only two gallons of uh oat milk left. Tell your agent what kind of information it needs to ask the user. confirm it if if two ounces are good enough. Do you want me to pick a backup for you? This information should be provided using context in injection as a technique and you can leverage this in

[33:00] the CLI that you are actually building. Try using it. Maybe you’ll be on the highest on the leaderboard. So we started a journey from T-Max which is basically screen scraping to injecting skills. So T-Max is low effort. I think a lot of you might have tried it. But this is where site channels [snorts] also will help you in providing [clears throat]

[33:32] good um sort of feedback to your agents and context injection will provide you those different scenarios that you can think about which doesn’t happen in the human case. So yeah, keep pushing your scores. You want to show this? >> Yeah.

[34:14] It does take some time. >> There you go. >> Okay, [snorts] cool. We do see a lot of traffic out here. [clears throat] [laughter] Oh, somebody is really close to 5,000. Is it bank? Okay. [clears throat]

[34:53] Any questions so far? Anybody wants to get it answered? Any queries? >> Sorry. >> [laughter] >> Okay, let me repeat that question to you. [clears throat] What happens if multiple people reach a score of 5,000? Mark, you want to take that? >> So, the the idea was we would look at score and if there’s a tie, we would

[35:25] look at which one took the least amount of time. Now, based on the resolution of this, I see several that are that have completed three of three in zero seconds. I see [laughter] a bunch of these that have completed it in zero seconds. So, I need to consult with someone because that’s not supposed to be possible. But the idea is that we would look at the high score the the score first and

[35:58] then the time it takes to respond second. So that an accurate response returned quickly would be biased over an accurate response returned slowly. So we have only one for now.

[36:29] >> Okay, sorry. >> We have only one. eventually comes to this is the bottom of the leaderboard. Nicholas [snorts] game up. [clears throat]

[37:09] 0 second. Do you want to

[37:41] wait two more minutes? We can open it up ideas how engaged they are. Did we have

[38:23] >> [clears throat] >> In just a few minutes, we’ll open up the floor for some idea sharing. So, I’m I’m hoping that we’ll hear some great ideas that go above and beyond our good ideas because I know that there’s some out there.

[38:58] Mark, were you expecting so many people to be in the 4,000? >> Yes, absolutely. >> At this conference? >> Absolutely. >> Awesome. Were you not? >> No, I was. [laughter]

[39:52] What do you think? Anybody can make it to 5,000? >> I don’t know. We’ll hold it open. [laughter] >> Why don’t we open the floor up now? >> Yeah, sure. We’d love to hear ideas. So, did anybody in the room come up with other ideas that were able to get them to such a high score so quickly? Nobody wants to leave the desk.

[40:24] [laughter] Oh, we have Yes. Let me let me come over to you

[40:55] [clears throat] because I can barely hear you. >> Okay. it it’s a very easy to game benchmark because the only thing that matters is you fulfill one order within like small like a very small latency. So if you do a deterministic parser um it which defeats the spirit of this challenge entirely but you deterministic parser

[41:26] and you have something like really close to the server you can get the latency down uh really quick if you just brute force it. >> Okay, which is that what you did? >> That’s what I’m doing right now. >> Okay. All right. Now you said something interesting the the deterministic parser that’s running in your CLI. Okay. I actually like the idea of the determinism in the CLI. And [clears throat] the reason is that

[41:59] if the CLI is a tool to be used by an LLM, then you absolutely want it to be deterministic. The LLM is the non-deterministic player here. We want the CLI to be as someone described it a small sharp instrument. Should be very very focused on what it does. And every time you give it a command, you want it to come back with the same response. So

[42:31] you don’t want to build an agent into the CLI and then hand that CLI off to another agent because you don’t know what you’re going to get. Any other interesting ideas? Obviously we a lot of people have figured out how to game the system. >> [laughter] >> Where there’s a Mac Mini, there’s a way, I guess. >> Yeah. [laughter]

[43:16] Wait five minutes. Five minutes. The score hasn’t changed in a while before the site crashes. >> Did you do refresh?

[43:57] >> [cough] [clears throat]

[44:41] >> Why does it say reconnecting? Oh, there we go. Okay. See, the network is a little laggy. The network is a little laggy out here. >> A lot of lot of computers. Sounds good. Crash.

[45:35] And we’re frozen right now. [clears throat] Here we go. No change in the results. Okay.

[46:11] Do we want to wait a few more minutes or call it? >> Yeah, five minutes. >> Five minutes. Okay. You want to bring the PPD to PPD for the closing arguments. >> We’re going to give it about five more minutes. >> Yeah. >> And then we’ll call it. >> Where’s Bon? Where’s Bonk? Raise your hand. >> Who is Bon? Okay, we have something. >> All right. Big smile. Big smile. [laughter]

[46:44] Now, >> we do want to hear how you did it. So once once we call it, then we’ll we’ll we’ll we’ll let you explain what you did. I’d love to hear. [laughter]

[47:15] I need to go over here. >> Yeah, >> hold on. Sorry. I should have asked for another I should have asked for another microphone for the room for questions. >> Um, yeah. So, Bonk is just a an agent uh thing built on top of cloud agent SDK. Um, it built the whole thing. Prior to this, I already had a sort of eval bench skill that will create sort of an

[47:45] environment and um optimize. So, it basically ended up building a uh deterministic CLI solver and then now it’s just running on a T-m slamming your APIs. >> Okay. >> Yeah. >> All right. aso. I think I got lucky because I hit it at one point at like 29 milliseconds. Uh probably because we’re in the same region. >> Okay. >> It’s just a network latency, >> right? And this is all done on claude >> uh claude agent SDK. Okay. Just driving it through Slack.

[48:16] >> No, which model? >> Opus 4.8. >> Okay. >> Yeah. >> Did you try it with any other models >> for the build uh for building the CLI or >> for for your a for your agent? How would we do that? The CLI is completely deterministic. Sure. Sure. So, so the agent built the CLI and is just running it on T-Max now. >> Okay. >> Yeah. >> Awesome. >> Yeah. >> Congrats.

[48:46] >> Going to go to the next one. Danny. Who’s Danny here? You see last one. [clears throat] What do we want to know? >> Yeah. How’d you build it? >> Yeah. So, I don’t know anything about uh

[49:19] coding at all. I’m I’m using uh I’m basically a Vibe coder. I have a couple agents and I just said, “Hey, here’s the problem. Read it and then fix it and fix it.” So, I just have Yeah. Cloud code up on uh VSC. >> Have you ever built a CLI before? >> Uh no. I I saw a couple hours ago that obviously there was a prize to be won. So, I got in and I said, “Hey, [laughter] uh figure this out. Explain it to me like I’m, you know, like I don’t know anything.” And then explain like I’m

[49:51] five. Yeah, I I I don’t know. So, and then we came up with uh yeah, we came up with some good results and I said, “Hey, we need to make it faster and give me some suggestions and yeah, seriously.” So, I I guess [snorts] we have uh two scripts running and the first one got the uh 49.98 and then I said, “Hey, make a copy and give me some suggestions for how we can get the 49.99.” >> Right. >> Did you get any suggestions? Uh it’s

[50:22] this agent’s pretty automated. So I just say like hey here’s the start here’s the end give me a couple you know questions at the beginning if you need it but then fix the problems so I don’t have to deal with it kind of thing. So sorry that’s not a very good >> No it’s good. I’m I’m sure a lot of people are wondering like writing a CLI is that something that you would ever do or would you ask your agent to do it for you? So clearly we have many people in

[50:54] the room and just going to point Claude or Codeex at this and say build a CLI, make it fast, make it deterministic. And those are the three ideas, right? Okay. You want to change the slide?

[51:36] There it is. >> [clears throat] >> So, we talked about all of our suggestions. We heard some ideas. The predominant idea was let your agent figure it out for you. I love that idea.

[52:06] Um, anything else before we close it out? All right, there you go. Takeaway for us based on our instructions, our recommendations. Give it good context, give it a side channel, and tell it to use T-Mox. Those are three good ideas to start with. Thanks everyone.

[52:37] Bonk, you want to come on up? [applause] >> We still have Monk as the winner, right? Yeah. Okay. No, no, we called it. We called it five minutes ago. >> Okay. >> Yeah. Yeah. I’m not gonna change [clears throat] I’m not going to change it. >> Yeah. >> We We called it. >> Awesome. [applause] >> Let us [clears throat] We’ll get We’ll just get a picture, >> you know, social media. That’s right.

[53:14] It’s a real Mac Mini. >> It’s a real Mac. Oh my god, these exist. [laughter] >> All right, awesome. >> Where’d it come? >> [music]