Tokens devem ter funções — Katelyn Lesse e Angela Jiang, Anthropic

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: Tokens Should Have Jobs — Katelyn Lesse & Angela Jiang, Anthropic · Canal: AI Engineer · 12:38 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Inferência e otimização de modelos

Resumo

Katelyn Lesse e Angela Jiang apresentam a ideia de atribuir funções diferentes aos tokens usados por agentes, em vez de tratar todos como recursos intercambiáveis. Elas descrevem estratégias de aconselhamento, avaliação e reflexão com gravação de aprendizados na memória, além da execução direta. Em experimentos com tarefas de análise financeira, essas estratégias tiveram desempenhos e custos diferentes, especialmente quando o sucesso exigia uma resposta 100% correta. A conclusão é que a estratégia mais adequada depende do objetivo — eficiência de tokens ou confiabilidade — e que combinações de agentes podem ser coordenadas por um harness.

Pontos-chave

Aumentar o orçamento de tokens não é a única maneira de melhorar o desempenho de um agente.
As estratégias apresentadas atribuem aos tokens funções de aconselhamento, avaliação e reflexão com registro de aprendizados na memória.
Nos experimentos, comparar estratégias exige manter o orçamento de tokens constante.
Em tarefas financeiras, respostas parcialmente corretas podem ser inúteis; por isso, as autoras também analisam a frequência de respostas 100% corretas.
A estratégia de aconselhamento pode ser mais eficiente em tokens, enquanto avaliação e reflexão podem favorecer a confiabilidade.
A escolha da estratégia depende do que o negócio precisa otimizar.
Um harness de nível superior pode coordenar vários agentes e combinar diferentes estratégias.
As primitivas também podem ser usadas para criar funções e arquiteturas novas para agentes.

Capítulos

Início	Capítulo	Resumo
00:19	A ideia de dar funções aos tokens	As apresentadoras questionam se todos os tokens são intercambiáveis e introduzem estratégias de aconselhamento, avaliação e reflexão.
02:23	Como funcionam as estratégias	Elas explicam o papel do aconselhador, do avaliador e do agente que registra aprendizados, com exemplos de uso.
04:33	Experimentos com tarefas financeiras	As apresentadoras comparam a execução direta e as demais estratégias, primeiro em tentativas únicas e depois com o orçamento de tokens controlado.
06:41	Custo de obter respostas corretas	A análise considera que, em tarefas financeiras, uma resposta só é útil se estiver 100% correta e compara o custo esperado das estratégias.
10:31	Coordenação de agentes e novas estratégias	As apresentadoras defendem combinar funções por meio de um harness e descrevem como primitivas podem sustentar arquiteturas mais complexas.

Citações

E se déssemos funções aos tokens? — 00:50

Se isso fosse a única coisa que importasse, esperaríamos que todas as estratégias tivessem o mesmo desempenho com o mesmo orçamento de tokens. — 06:08

Tokens não são intercambiáveis. — 10:31

Vocês devem dar funções aos seus tokens e combinar estratégias novas para alcançar os resultados desejados. — 12:38

Conceitos e entidades

Anthropic (empresa): Empresa em que Katelyn Lesse lidera a engenharia de plataforma e Angela Jiang lidera o produto de plataforma.
Katelyn Lesse (pessoa): Apresentadora que lidera a engenharia de plataforma na Anthropic.
Angela Jiang (pessoa): Apresentadora que lidera o produto de plataforma na Anthropic.
tokens should have jobs (conceito): Ideia de atribuir aos tokens funções diferentes, em vez de usá-los apenas para executar uma tarefa.
advising (conceito): Estratégia em que um agente executor pode consultar outro agente para receber aconselhamento.
grading (conceito): Estratégia em que um avaliador compara o trabalho do executor com uma rubrica e permite novas tentativas.
dreaming (conceito): Estratégia em que um agente analisa o trabalho e as transcrições do executor e registra aprendizados na memória para execuções futuras.
Harness (conceito): Estrutura que dá suporte a agentes e pode ser ampliada para coordenar vários agentes e estratégias.

Tradução completa (pt-BR)

00:19 Bom dia. Estamos muito empolgadas por estar aqui no AI Engineer com todos vocês. Sou Caitlyn e lidero a engenharia de plataforma na Anthropic. >> E eu sou Angela. Lidero o produto de plataforma na Anthropic. Hoje queremos falar com vocês sobre um conceito em que temos pensado bastante e no qual temos trabalhado com nossa equipe: a ideia de que os tokens devem ter funções. Quando você está construindo um sistema agentic e tentando alcançar um resultado específico, tentando fazer algo com agents, há uma alavanca que todo mundo aciona para

00:50 obter um resultado melhor, e geralmente é aumentar o orçamento, o que significa gastar mais tokens ou usar tokens mais caros. Mas temos nos perguntado: será que é só isso? Por trás dessa suposição de usar o orçamento há uma perspectiva implícita de que cada token é basicamente fungível. E temos nos perguntado: isso é mesmo verdade? Todos esses tokens são realmente fungíveis? Para testar isso, pensamos: e se déssemos funções aos tokens? Então, se você pensar na maneira como normalmente

01:21 configuraria um agent para realizar uma tarefa, você dá a tarefa a ele, define esse orçamento de tokens e, então, todos os tokens gastos são basicamente indistintos, no sentido de que todos fazem o mesmo trabalho. Eles apenas executam. Mas e se alguns desses tokens não estivessem apenas executando, mas fazendo outro trabalho? Por exemplo, talvez alguns tokens aconselhem os tokens que estão executando. Ou talvez os tokens que estão executando tentem fazer algo bem, enquanto outros tokens avaliam o quão bem o

01:52 executor está se saindo, para que ele possa iterar e tentar de novo. Ou talvez você tenha tokens que sonham. Eles refletem sobre o trabalho feito por outros executores e registram aprendizados na memória, para que possam fazer isso de novo. E é a cada uma dessas combinações — alguns tokens executando e outros fazendo algum outro trabalho — que damos o nome de estratégia. Vamos ver a primeira estratégia: aconselhamento. Aqui, dividimos o trabalho entre um executor e um consultor. O executor, obviamente,

02:23 executa, mas, o que é crucial, pode pedir orientação a um consultor. Depois, pode usar essa orientação para descobrir se está fazendo corretamente a próxima etapa. Isso é muito útil em casos de uso como, por exemplo, construir um agent de vendas. No mundo ideal, esse agent de vendas conseguiria ajudar o representante de vendas a identificar quando um acompanhamento está atrasado ou quando uma negociação está estagnada. Nessa estrutura, é muito útil ter um consultor que possa garantir que todas as diferentes partes estejam realmente funcionando. Outro exemplo é a avaliação. Digamos que você esteja executando e saiba exatamente como seria um bom resultado.

02:56 Você pode definir isso em uma rubrica e, cada vez que um executor tentar alcançar esse resultado, pode disponibilizar um avaliador para julgar o desempenho do executor usando essa rubrica. Se o executor fez um bom trabalho, ótimo, pode encerrar por aí. Mas, se não fez um trabalho tão bom, pode iterar de novo até obter um bom resultado. Um exemplo prático de quando você poderia usar isso: digamos que você tenha um agent de atendimento ao cliente e esteja administrando uma loja. Seus clientes escrevem dizendo: “Oi, eu deveria receber um reembolso por esse produto.” E

03:27 seu agent de atendimento ao cliente precisa responder. Provavelmente, você tem critérios bem específicos para decidir quando dar um reembolso a alguém. Então, o que pode fazer é definir uma rubrica que use esses critérios. Você pode ter um avaliador que analise o trabalho do agent de atendimento ao cliente e decida se ele está acertando e chegando ao resultado correto. A última estratégia que temos é sonhar. Nela, há um executor que realiza a execução normalmente e também há um sonhador. O sonhador consegue inspecionar o trabalho e as transcrições do executor e, então,

04:00 usa as descobertas que fez e as registra na memória. O executor recupera essa memória na rodada seguinte. Assim, idealmente, seu desempenho melhora. Um ótimo caso de uso para isso é construir um agent de recrutamento. O recrutamento exige muita interação e feedback sobre se um candidato faz sentido ou não e se há uma boa compatibilidade entre as duas partes. Ao usar todos esses dados e construir uma estratégia do tipo sonhador para esse agent, ele consegue aprimorar a rodada seguinte, tornando-se cada vez mais útil. Vamos concretizar isso com alguns experimentos. O que fizemos foi

04:33 criar um benchmark com várias tarefas relacionadas a análises financeiras. Em cada uma dessas tarefas, tentávamos replicar, no mundo real, o trabalho de um analista financeiro humano especialista. Qual seria o desempenho dele em cada uma dessas tarefas? Começamos com um controle que apenas executa. Vamos tentar cada uma dessas tarefas e avaliá-las quando estamos simplesmente executando. Depois, podemos experimentar cada uma das nossas estratégias e ver qual é o desempenho. Então, começamos com um experimento bem básico. Vamos fazer uma única tentativa. Vamos

05:03 pegar cada uma das nossas estratégias, tentar realizar essas tarefas e ver qual é a nossa precisão. Como podem ver, a execução não se saiu muito bem: 15% de precisão. Mas, como foi uma única tentativa, a estratégia pôde escolher quantos tokens gastaria por conta própria. E dá para ver que a execução decidiu não gastar tantos tokens, apenas 39 mil. Nas estratégias maiores, mais complexas, de fato optamos por gastar mais tokens, mas fizemos um trabalho melhor. Então, isso não nos diz muita coisa, porque, sim, Dream se saiu muito,

05:36 muito bem, mas usou impressionantes 600 mil tokens para chegar lá. Isso mesmo. Então, para descobrir se variar as funções produz algum alpha, precisamos manter o orçamento constante. Para isso, vamos usar o orçamento de Dreaming — cerca de 600 mil tokens — como o orçamento máximo, fixo para todas as estratégias. Damos esse orçamento a cada estratégia para analisar seu desempenho. E, como esperado, mais uma vez, se você der mais orçamento a várias estratégias, verá o desempenho aumentar de forma geral. A execução passou de 0,15 para 76. Aconselhamento e avaliação

06:08 passaram da casa dos 60 para perto dos 90. Isso também era esperado, já que, se você der mais tempo de teste de computação, em geral as coisas devem ter um desempenho melhor. Mas, se isso fosse tudo o que importasse, deveríamos esperar que execução, aconselhamento, avaliação e sonho ficassem todas exatamente no mesmo nível, dado o mesmo orçamento de tokens. Mas o que estamos vendo é que existe um alpha, ou seja, há uma diferença e, portanto, um alpha que podemos explorar. Se você olhar para a execução com esse mesmo orçamento, ela chega a 76, mas o aconselhamento fica em 89. Então, embora seja mínimo, o alpha existe e há algo para

06:41 analisarmos. Agora, decidimos examinar essa análise por uma perspectiva completamente diferente. Como Kayla mencionou, estamos fazendo esse benchmark para um conjunto muito complexo de tarefas financeiras do mundo real. E queríamos analisar o uso de agents por especialistas de verdade. Se olharmos para um analista financeiro especialista, o tipo de tarefa que ele precisa fazer com um agent é algo bem concreto, como, por exemplo, pedir para montar uma demonstração de resultados e, depois, receber o resultado. Se esse resultado tiver 80% de precisão no benchmark, isso parece ótimo, mas, na realidade,

07:16 O que isso significa para esse especialista é que ele precisa voltar e recalcular esse P&L por conta própria ou, alternativamente, enviar o trabalho para outra execução. E isso porque, nesse tipo de área e para esse tipo de tarefa, se você não tiver 100% de precisão, o resultado não será útil. Você não pode inventar um valor de receita nem um valor de custo, certo? Precisa garantir que tudo tenha 100% de precisão. Então, levando em conta as consequências reais associadas a essa área, precisávamos recalcular nossos experimentos e avaliá-los de um jeito um pouco diferente. Fundamentalmente, precisávamos garantir que nosso experimento tivesse essa estrutura: se recebesse uma pontuação perfeita, de fato seria aprovado.

07:50 E, se recebesse menos de 100% nesse tipo de tarefa, nós o marcaríamos como uma falha. Então, vamos analisar um recorte diferente dos dados dos nossos experimentos sob essa perspectiva, em que buscamos uma execução perfeita, aprovada com 100% de precisão. Vamos ver em que porcentagem das vezes cada uma dessas estratégias conseguiu ser aprovada. Então, temos a estratégia de execução com 42%, e nossas estratégias mais complexas se saem um pouco melhor, chegando a 75% de precisão. E, de novo, isso não necessariamente nos diz muita coisa, porque você…

08:22 sabe, cada uma dessas estratégias pode optar por usar orçamentos diferentes ao longo do tempo, certo? Então, o que fizemos foi fixar o orçamento e perguntar: com um orçamento fixo, qual é o desempenho de cada uma dessas estratégias? O que realmente importa para nós é, na verdade, o custo para você chegar à resposta perfeita, se está tentando obter essa resposta no mundo real e administrando uma empresa. Uma maneira de pensar nisso é considerar, por exemplo, nossa estratégia de execução. A estratégia de execução vai fornecer a resposta perfeita em cerca de 40% das vezes. Então, em

08:55 média, você pode esperar ter que executá-la três vezes e, esperamos, obter uma resposta perfeita em alguma dessas três execuções. E, como mencionamos antes, fixamos o orçamento no valor mais alto entre as estratégias: 600 mil tokens. Então, se você gastar 600 mil tokens em cada execução individual, precisará executá-la aproximadamente três vezes. Em média, pode esperar gastar 1,8 milhão de tokens com a estratégia de execução para chegar à resposta perfeita. E, se aplicarmos essa análise a todas essas estratégias, esse é, na verdade, o custo real para que esse

09:29 agent fosse útil nessa área, usando aquela estratégia. Então, como a Caitlyn mencionou, para a estratégia de execução, que é nossa linha de base, o custo total real será de 1,8 milhão de tokens para você. Mas as estratégias de aconselhamento, avaliação e sonho apresentam resultados um pouco diferentes. Fundamentalmente, as estratégias de aconselhamento e avaliação são bastante eficientes em tokens quando consideramos o uso efetivo do resultado final de cada um desses agents. O que isso significa para você como empresa? Bem, depende muito do que você quer otimizar, e isso vai variar, certo? Haverá empresas que dirão: “Na verdade, para mim, o mais

10:01 importante é ser muito eficiente em tokens. Nesse caso, provavelmente você deve escolher o tipo de estratégia de aconselhamento para resolver o problema específico daquela área que quer otimizar.” Haverá outras áreas ou empresas que dirão: “Não vou me preocupar tanto com a eficiência em tokens, porque o que realmente me importa é a confiabilidade da resposta. Então, preciso maximizar a porcentagem de execuções em que obtenho a resposta perfeita.” Nesse caso, você escolheria estratégias completamente diferentes. Provavelmente optaria por avaliação ou sonho. Então, se você guardar uma coisa, queremos que todos pensem nesta

10:31 ideia: tokens não são intercambiáveis. Você pode usar seus tokens para executar. Pode resolver sua tarefa à força bruta e alocar mais orçamento para ela. Mas, se pensar com cuidado em como dar diferentes funções aos seus tokens e testar estratégias diferentes, é muito provável que consiga um resultado melhor para a tarefa em questão dentro de um orçamento fixo. Então, vamos conversar um pouco sobre como, de fato, criamos estratégias e as colocamos em prática. Fizemos muito trabalho para criar um harness realmente excelente para agents individuais. E, se você olhar para a imagem na parte de baixo

11:03 aqui, esta é, na verdade, a arquitetura que usamos para o Claude Managed Agents, nossa solução agentic que oferecemos na plataforma Claude. E, sobre essa base, começamos a trabalhar no nível de meta-harness, ou seja, no nível de orquestração e execução multi-agent, em que essa estratégia pode ser coordenada entre nosso executor e nosso consultor, ou entre os outros agents da estratégia. E alguns desses recursos, como sonhar e os resultados, já são oferecidos prontos para uso no Claude Managed Agents.

11:34 Com esse conjunto de componentes básicos, é relativamente simples para nós construir esse tipo de arquitetura e descobrir como combinar esses diferentes tipos de estratégia e fazê-los funcionar juntos. Por exemplo, é relativamente simples dizer: “Certo, agora posso pegar uma tarefa e executá-la, mas também permitir que ela dê conselhos, e o Fable está de volta.” Então, poderíamos dizer que o Fable é quem está aconselhando o executor. Depois, posso pegar todos esses resultados e enviá-los para um avaliador, para garantir que ele esteja verificando tudo em um ciclo que faça sentido. E, se for aprovado, ótimo. Quero

12:07 enviar tudo isso para o modo de sonho e garantir que minha próxima execução seja melhor do que nunca. E, claro, você não precisa parar por aí, certo? Se os componentes básicos certos estiverem disponíveis e houver a coordenação adequada, você pode construir configurações realmente complexas, adequadas a todos os diferentes tipos de problemas dinâmicos que enfrenta. Você pode inventar esse tipo de arquitetura em grande escala — de novo, é muito simples. E também pode inventar funções completamente novas, não apenas aquelas que a Caitlyn e eu apresentamos nesta conversa. Então, um dos nossos grandes objetivos ao longo do tempo é

12:38 tornar nossos modelos cada vez melhores e nossa plataforma cada vez melhor em construir dinamicamente essas estratégias para você enquanto trabalha. Mas, enquanto isso, à medida que avançamos nessa direção, gostaríamos muito que você continuasse pensando nesta ideia: você deve dar funções aos seus tokens e usar estratégias diferentes e inovadoras, combinando esses componentes básicos para obter os resultados desejados nas suas tarefas. >> Obrigado por se juntar a nós.

Transcrição original

[00:19] Good morning. We’re super excited to be here at AI Engineer with all of you. I’m Caitlyn and I lead platform engineering at Anthropic. >> And I’m Angela. I lead platform product at Anthropic. And today we want to talk to you about a concept that we’ve been spending a lot of time thinking about and working on with our team, which is this idea that we think that tokens should have jobs. So if you’re building an agentic system and you’re trying to accomplish some specific outcome, you’re trying to get something done with agents, there’s one lever that everybody pulls in order to

[00:50] get a better outcome, and that’s usually increasing your budget, which means you spend more tokens or you spend more expensive tokens. But we’ve been wondering is that all there is underlying this assumption of uh using the budget is this kind of implicit perspective that every single token is basically fungeable. And we’ve been wondering is that actually true? Are all these tokens actually fungeible? And to test that, we’ve been thinking, what if we gave tokens jobs? So, if you think about the way that you

[01:21] would normally set up an agent to go accomplish a task, you give it that task, you give it this token budget, and then all the tokens that are being spent are basically indiscriminate in the sense that they’re all doing one job. They’re just executing. But what if you take some of those tokens and they’re not just executing, they’re doing some other job. So, for example, maybe you take some of your tokens and they’re advising the tokens that are executing. Or maybe the tokens that are executing try to get something done well and you take some other tokens and you actually grade how well the

[01:52] executor is doing so that it can iterate and try again. Or maybe you have tokens that are dreaming. They’re reflecting back on the job that other executors have done and writing learnings to memory so that they can do it again. And what we call each of these if you take some tokens that are executing and some tokens that are doing some other job. Let’s call this a strategy. So let’s go take a look at the first strategy, the advising strategy. Here we’re splitting up an executor and an adviser. The executor obviously

[02:23] executes, but crucially they can call out to an adviser for advice. And then they can take this advice and figure out if they’re doing the next step correctly. This is really helpful in use cases. For example, if you’re building a sales agent, in an ideal world, you’d have that sales agent be able to actually help the sales rep flag when a follow-up is overdue or deal is stalling. In this construct, having an adviser to be able to kind of make sure that all the different pieces are actually working is really helpful. So another example is grading. Let’s say you’re executing and you kind of know exactly what good really does look like.

[02:56] You can define this in a rubric and then each time an executor tries to accomplish that outcome, you can have a grader provisioned that grades how well the executor did while looking at that rubric. And if the executor did a good job, then great, it can be done. But if it didn’t do such a great job, you can iterate again until you get that good outcome. So an example in practice of when you might want to use this is let’s say you have a customer service agent and you’re running a store and your customers are writing in and they’re saying, “H, I should get a refund for this thing.” And

[03:27] your customer service agent needs to be able to respond. You probably have some like pretty specific criteria on when you would give somebody a refund. And so what you can do is define a rubric that uses that criteria. You can have a grader that goes and looks at the work that the customer service agent is doing and decide is it getting it right and is it coming to the right outcome. And the last strategy we have is dreaming. So in dreaming there’s an executor who naturally executes and then there’s a dreamer. The dreamer is actually able to inspect the work and the transcripts of the executor and then

[04:00] it takes any of the findings that it has and it writes them to memory. This memory is repicked up by the executor for the next round. So ideally would have improved. A great use case for this is if you’re building a recruiting agent. Now recruiting requires a lot of interaction with feedback on whether or not a candidate does or doesn’t make sense and if it’s a good fit between both parties. And so by taking all this type of data, if you build a dreaming type of strategy on this agent, it’s actually able to kind of sharpen the next round so that it’s more and more increasingly useful. So let’s make this concrete with some experiments. So what we did was we

[04:33] created a bench of a bunch of tasks related to financial an analysis. And what we were doing with each of these tasks is trying to replicate in the real world a expert human financial analyst. How well would they do on each of these various tasks? And so what we did was we start with a control that’s just executing. Let’s try each of these tasks and we’ll eval them when we’re literally just executing. But then we can experiment with each of our strategies and see how well we perform. So, we start with a super basic experiment. Let’s just oneshot it. Let’s

[05:03] take each of our strategies and we’ll go and just make an attempt to accomplish these tasks and we’ll see how accurate we are. And so, you can see here with executing um it didn’t do so well. 15% accuracy, but because it was just a oneshot, the strategy got to choose how many tokens it would actually spend on its own. And so, you can actually see that execute decided not to spend that many tokens, only 39,000. And as we go into our larger strategies, our more complex strategies, we did choose to spend more tokens, but we did a better job. So, this isn’t really telling us much because sure, Drain did really,

[05:36] really well, but it used a whopping 600,000 tokens to get there. That’s right. So, in order to actually figure out if varying the jobs produces any alpha, what we need to do is hold the budget constant. And to do this, we’re going to take Dreaming’s budget, that 600,000 or so, as the maximum budget that is fixed across the board. And we give every single strategy this budget in order to analyze how well it’s performing. And as expected again, if you give a lot of strategies more budget, you are going to see performance increase across the board. So execute went from 0.15 to 76. Advise and grade

[06:08] went from the 60s to closer to the 90s. And that’s again expected given the fact that if you give things more test time compute, they should generally perform better. But if that was the only thing that mattered, we should actually expect to see execute, advise, grade, dream actually all be at the exact same level given the exact same token budget. But what we’re actually seeing is that there is an alpha or there is a difference and therefore an alpha for us to exploit. If you look at execute at this exact same budget level, it gets to 76 but advise is at 89. So while a minimal, it does exist and so there is alpha for us to

[06:41] take a look at. Now, we decided to take a look at this analysis from a completely different lens. And as Kayla mentioned, you know, we’re doing this bench for a very complex set of financial tasks in the real world. And we wanted to analyze the usage of agents with actual experts. So, if we look at a financial analyst expert, right, the kind of task that they need to do with an agent is that they’re giving it something very concrete like let’s say make a P&L and then they’re getting the result back. Now if that result is 80% accurate on a bench that sounds great but in reality

[07:16] what that means for that expert is they have to go back and recomputee that P&L themselves or alter or alternatively send it through another run and that’s because in this kind of domain for this kind of task if you’re not 100% accurate it’s actually not useful. You cannot make up an income number or you can’t make up a cost number right you have to make sure that it’s 100% accurate. So with this lens of the real world consequence associated with this domain, we needed to recomputee our experiments and score them a bit differently. Crucially, we needed to make sure that our experiment had this kind of construct where if it was scored perfectly, we’d actually give it a pass.

[07:50] And if it scored anything less than 100% on that kind of task, we would actually mark it as a failure. So let’s look at a different cut of our data from our experiments with this lens where we’re looking for this perfect run 100% accuracy pass. And let’s look at what percent of the time each of these strategies was able to achieve a pass. Um so we we’ve got executes um down at 42% and we’ve got our more complex strategies doing a bit better up to 75% accuracy. Um and again this doesn’t necessarily tell us a ton because um you

[08:22] know each of these strategies might um choose to use different budgets over time, right? So what we did here was we fixed the budget and we said within a fixed budget, how well do each of these strategies perform? And so what really matters to us actually is if you’re trying to get this perfect answer and you’re in the real world, you’re running a business, what matters to you is the cost to you to get to that perfect answer. And so one way we can think about this is we had our execute strategy for example. The execute strategy around 40% of the time will give you that perfect answer. So on

[08:55] average, you can expect to have to run it three times and you should hopefully sometime in those three runs get a perfect answer. And as we talked about earlier, we fixed our budget to that highest token budget strategy, which was 600,000 tokens. So if you spend 600,000 tokens in each individual run, you have to run approximately three times. You can expect on average to have to spend 1.8 million tokens with the execution strategy to get to your perfect answer. And so if we take this analysis and run it across the board against all these strategies, this is actually the true cost it took in this domain for that

[09:29] agent to be useful for that strategy. So as Caitlyn mentioned for execute, which is our baseline, this is going to be 1.8 million true total token cost for you. But advise, grade, and dream are showing us a bit of difference. Crucially, advise and grade are actually quite token efficient when you think about the actual usage of the end output of each of these agents. So what does this mean for you as a business? Well, it actually really depends on what kind of thing you want to optimize for and it’s going to vary, right? There’s going to be businesses who say, “Actually, for me, the most

[10:01] important thing is to be really token efficient. In that case, you should probably pick the advised type of strategy in order to solve for that particular domain in which you want to optimize that.” There’s going to be other areas or other businesses where you’re going to say, I’m not going to care so much about token efficiency because what I really care about is reliability of that answer and so I need to maximize the percentage of runs in which I get that perfect answer. In which case, you would actually pick completely different strategies. You probably lean towards grade or dream. So if you take away one thing, the thing we want everyone to think about is this

[10:31] idea that tokens are not fungeible. You can use your tokens to execute. You can brute force your way through your task and you can throw more budget at it. But if you get really smart about having your tokens do these different jobs and try these different strategies, you’re very very likely to be able to get a better outcome for the task at hand within a fixed budget. And so let’s talk a little bit about how we actually build strategies and how we bring this to life. Um so we’ve done a lot of work to create a really excellent harness for individual agents. Um and if you see this uh picture at the bottom

[11:03] here, this is actually the architecture that we’ve used for cloud managed agents um which is our Aentic solution that we give to you within the cloud platform. And what we do on top of this is we start to get into the meta harness level like the multi- aent orchestration and execution level where this strategy can go and be um coordinated between our executor and our adviser or the other agents within our strategy. And some of these um like dreaming and outcomes we actually give to you out of the box within cloud manage agents.

[11:34] So with those set of primitives it’s actually relatively trivial for us to construct this kind of you know architecture where we’re able to combine these different types of strategies and figure out how to they should work together. So for example it’s relatively trivial for us to say okay now with this I can take a task and I should be able to execute it but also allow it to advise and fable is back online. So we could actually say Fable is the one that’s actually advising uh the executor. And then I can take all these results and say send them to a greater so that I can make sure that this is verifying in a loop that makes sense. And if it passes, that’s awesome. I want

[12:07] to send all of that stuff to Dreaming and make sure that my next run is better than ever. And of course, you don’t have to stop there, right? If the right primitives are there and the right coordination is there, then you can actually construct really complex setups that fit for all the different types of dynamic problems that you have. You can invent these kinds of large-scale architectures, again, very triv. And you could also invent completely new jobs, not just the ones of the pieces that Caitlyn and I have presented in this conversation. So, a big goal that we have over time is

[12:38] to get our models better and better and our platform better and better at dynamically constructing these strategies for you as you’re doing work. But in the meantime, as we’re working our way there, we would love for you to continue to think about this idea that you should give your tokens jobs and you should use different novel strategies by combining these primitives in order to get the outcomes that you want for your tasks. >> Thanks for joining us.