Burn Your Flags: Interactive CLIs for Agents — Mark Lummus & Navinkumar Patil, PayPal
Read the talk
Burn Your Flags: Interactive CLIs for Agents
Mark Lummus and Navinkumar Patil use a coffee-ordering workshop to explain how agents lose terminal state, how structured interfaces can preserve interactive guidance, and why a fast benchmark result can reward something different from the intended task.
From a talk by Mark Lummus and Navinkumar Patil
At a glance
Ideas worth remembering
An interactive CLI can fail silently when its harness receives redraw output but loses the prompt’s UI state.
tmux preserves an inspectable terminal session; a structured side channel exposes state and accepts input as data; context explains constraints and required confirmations.
Keep the CLI’s operations predictable so the reasoning agent can choose among them without managing another agent inside the tool.
The competition rewarded deterministic specialization and low network latency, limiting what leaderboard success demonstrated about interactive agent capability.
The prompt is waiting. The agent cannot see the question.
An interactive command can stop making progress without returning an error. In this PayPal workshop, Mark Lummus, Head of Developer Tools, and Navinkumar Patil, the developer tools tech lead, start with that quiet failure: an agent shells out to a CLI, but its harness does not handle the interaction that follows. The command is running. The interface has become unusable to its new operator.
What does each operator receive? The opening example is an arrow-key prompt. A human sees a question and navigates its choices. The agent receives a redraw loop, and the harness loses the UI state. The important distinction is between receiving terminal output and retaining the question that output represents. Here, the latter fails silently.
$ barista brew
? size (Use arrow keys)
small
medium
› large
# the agent sees a redraw loop
# not a question
✗ no answer ever arrives
Adding command flags is the obvious repair, and Lummus gives it a clear place: a single pass through a known workflow whose inputs are independent. Interactive workflows become harder to flatten when one answer determines the next question. A CLI might also call an API and ask a question based on the response. Enumerating options in advance then has to account for decisions that only become meaningful during execution. Guidance and guardrails already present in the interactive flow can disappear in that translation.
An agent can potentially follow that branching process: reason about a response, ask, retry or back up. A fixed automation script has its decisions arranged ahead of time. The design question is therefore how to expose the decision tree to an agent that cannot reliably read the human interface. Lummus borrows the model of accessibility: “the same discipline with a new reader.” Preserve the guidance while giving the new reader a form it can use.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Barista 9000 makes the interface problem concrete
Barista 9000 is the workshop’s deliberately troublesome coffee-ordering CLI. Participants receive the CLI, change it, run it through an agent and submit information to a server that updates a leaderboard. A Mac Mini supplies the incentive. The desired outcome is simple enough to recognize—brew a coffee—but the original interactive interface is expected to fail when operated through an agent.
Patil places the exercise in a longer development-tool story: Eclipse, IntelliJ, VS Code and then AI editors such as Cursor and Windsurf. CLIs persisted through those changes; agents have given them renewed importance. Participants download the bare CLI from PayPal Cafe, register a name and try to complete an order. The init command handles registration. This is a working exercise, with hints introduced after participants have had time to encounter the problem themselves.
The hints are deliberately called “good ideas,” rather than best practices. Lummus treats this as an early design space where the audience may discover better approaches. That framing matters: the workshop offers ways to make the interface accessible, without claiming a settled standard for every agent harness.
Model choice adds another constraint. Lummus expects a frontier model at its highest thinking setting could probably brute-force the challenge, but asks participants to try Haiku or Sonnet, or a comparable faster, cheaper model. The useful engineering question is whether a clearer interface can spare the token budget otherwise spent navigating a CLI. This is a proposed challenge, rather than a measured comparison of models.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
First hint: keep a terminal session the agent can inspect
At roughly 26 minutes, Patil introduces tmux as the lowest-effort starting point. Begin with the CLI’s help command so the agent can discover how to operate it. Then use a terminal session that remains available for subsequent input and inspection, rather than treating the interactive command as a single request that must immediately finish.
How does the agent act on that session and observe the result? The two useful operations are sending keys and capturing a pane. Sending keys supplies the input an interactive program expects; capturing the pane returns the terminal contents the agent can inspect before choosing another input. The example also introduces detached execution, allowing the CLI to keep running while the agent works through these separate operations.
bash
# launch the CLI inside a detached pane
$ tmux new -d -s barista brew 'brew'
# read the screen
$ tmux capture-pane -p -t brew
? size › small medium [large]
# answer it
$ tmux send-keys -t brew Down Enter
✓ selection advanced
Separate sessions can hold separate long-running tasks, including work associated with multiple agents. The immediate advantage is continuity: the running process and its terminal remain available to revisit. The remaining cost is interpretation. The agent still has to recover meaning from terminal presentation, which motivates the next hint.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Second hint: expose state and input as data
An IPC side channel gives the agent a structured way to communicate with the CLI. Patil’s analogy is a website with a REST API: the visual interface serves humans, while the API exposes machine-readable information. The CLI can similarly serve both operators without asking the agent to infer everything from a terminal redraw.
The operating principle is compact: “Read state, send input as a data.” JSON makes the prompt’s meaning explicit. Instead of locating an option on screen and translating it into arrow presses, an agent can receive a description of the current question and submit an answer as data. Patil introduces barista brew --agent in this discussion as an agent-facing mode; the explanation does not specify the underlying IPC transport.
What information must survive that change in representation? The coffee-size example includes a field, the choices small, medium and large, and a default of large. Those details tell the agent what it is answering, which answers are available and what the default means. They are useful input data, rather than decoration around a human prompt. Exposing them in a machine-readable format removes a layer of screen interpretation while retaining the choices.
The distinction between the first two hints is practical:
- Terminal access: send keys and inspect a captured pane while keeping the interactive process running.
- Structured access: read explicit state and submit input as data, reducing dependence on the rendered terminal.
The second approach requires an interface for structured communication, but it gives the agent information closer to the decision it must make.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Third hint: include the constraint behind the next question
Structured choices alone do not explain every decision. Context injection supplies information the agent needs to interpret those choices and ask useful follow-up questions. Patil describes providing the information together in an input file, rather than relying exclusively on the sequence of options a human sees.
The example is low oat-milk stock. The agent should receive the constraint and guidance about what to confirm with the user: is a smaller amount acceptable, and should it choose a backup? Patil mentions two gallons remaining and a question about two ounces; these quantities illustrate inventory context and a possible serving confirmation, without defining a complete stock-allocation rule. The useful mechanism is making the shortage and the required confirmation available before the agent chooses how to proceed.
The three hints address different needs. tmux supplies continuing access to the terminal. A side channel supplies clearer feedback and structured interaction. Context supplies the scenario that makes a particular question necessary. They can complement one another: a communication path gets the agent to the decision, while contextual information helps it make that decision sensibly.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The leaderboard starts rewarding a different problem
As scores approach 5,000, an audience question exposes the ranking rule. The intended order is score first, then response time: an equally accurate response should rank higher if it arrives sooner. But several entries appear to have completed three of three in zero seconds. Lummus flags that display as unexpected. The zero-second values do not establish instantaneous completion; the timing issue remains unresolved in the discussion.
When the floor opens, a participant identifies a more consequential limitation: the benchmark is easy to game by fulfilling one order with very low latency. A deterministic parser can handle that narrow task, and placing it close to the server can shorten the network trip. The participant says this is what they are building. Success can therefore come from specializing the solution and reducing network latency, without demonstrating better general navigation of an interactive workflow.
Lummus accepts the benchmark criticism while finding a useful design decision inside the workaround: keep the CLI deterministic. The LLM already supplies a variable decision-maker. The tool should remain a “small, sharp instrument,” focused on a predictable operation. Putting another agent inside that tool adds another source of uncertainty for the outer agent to manage.
That recommendation also qualifies what predictability means for the earlier API-driven examples. Live stock or API responses can change the available choices; a useful CLI still needs consistent handling of its current inputs and state. Interactive branching and predictable tool behavior can coexist. The reasoning agent chooses a path through the workflow, while the CLI carries out its defined operations.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
An agent builds the solver; the solver handles the orders
The leading participant’s explanation makes the distinction between building and running especially clear. Their agent uses the Claude Agent SDK, with Slack as the control interface. An existing evaluation-bench skill creates an environment and optimizes the solution. For this challenge, the agent builds a deterministic CLI solver, then runs it in tmux against the APIs.
The participant reports one response at about 29 milliseconds and suspects the client and server are in the same region. That location explanation is their hypothesis. More importantly, when Lummus asks about model choice, the participant clarifies that the completed CLI is deterministic: the agent built it and now runs it through tmux. Model reasoning is used to construct the solution; it is no longer required to decide each order in the resulting solver.
This result answers a narrower question than the workshop’s original challenge. It demonstrates an agent producing a fast, specialized program and operating it in a persistent session. It does not establish that a cheaper model can now navigate arbitrary interactive prompts. The benchmark has made an alternative economical: use the agent to build away the repeated reasoning task.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A first CLI, then a request to make it faster
Danny, another participant, reaches the exercise from a different starting point: no previous CLI-building experience and little coding knowledge. Using Claude Code in VS Code, Danny gives the agents the problem and asks them to read it, explain it and fix it. The interaction is goal-driven, with the agents handling the implementation details.
After the first working result, the request becomes concrete: make it faster and suggest improvements. Danny reports two scripts running, with the first scoring 4,998, then asks for a copy and suggestions to reach 4,999. The recording does not reveal the script changes, so this example supports a development pattern rather than a particular speed optimization: obtain a working solution, inspect the result, and ask the agent to pursue the next specific outcome.
Lummus recognizes that many participants have chosen to ask an agent to build the CLI itself: “Make it fast. Make it deterministic.” The workshop ends with that audience contribution alongside the presenters’ original recommendations—give the agent useful context, a side channel and access through tmux. Those remain “good ideas to start with.” The competition adds a practical distinction: sometimes the agent needs a better way to follow an interactive decision; sometimes it can build a predictable program that handles the narrow task directly.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Related talks
- Beating RL With Reflection: GEPA and Optimize Anything
Develops the evaluation and optimization side of the agent-built solver example: using execution feedback to improve programs, harnesses and reusable skills.
Read the complete timestamped transcript
- 0:12
Hi, everyone. Welcome in. My name is Mark Lummus. I'm Head of Developer Tools at PayPal. With me, I have Navinkumar. He's our tech lead for the developer tools team. And today, we're gonna 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.
- 0:43
So today, we're gonna talk a little bit about a specific kind of CLI, interactive CLI, and we're going to set up an exercise. And we're gonna 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
- 1:13
workshop today. So we're gonna 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.
- 1:24
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-DOS before we had Microsoft Windows? There you go. My first job out of college, I was designing embedded systems, and so you would connect to a computer
- 1:54
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 k-kind of had a resurgence, I guess, you know, with the-- maybe it was Claude Code that really made them much more popular. Now we have Codex. Um, and so a lot of people are, are adding CLI, uh,
- 2:24
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 wanna talk about. Um, agents shell out to bash constantly, and that's good. But if they run an interactive CLI, that may be bad because not all harnesses handle
- 2:55
interaction very well. And if they don't handle it very well, they'll fail quietly. You won't know. No errors, no nothing.
- 3:05
But why do we care? Interactive CLIs are great because the next question can emerge based on what-- the way you answer a previous question. Flags multiply if you try to create flags that predict w- 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
- 3:35
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 guardrails can live in the interactive flow.
- 3:55
So here's an example. Over here on the, on the left, we see a, a, a sample CLI. It's interactive. The CLI's opened an interactive prompt, an arrow 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
- 4:25
loses the UI state. So here's the failure mode. It's silent and invisible.
- 4:35
So the common fix, we'll just add flags. And flags are fine for simple use cases. You have, uh, you know what the, you know what the flows are upfront. It's a single pass. All the options are independent. Great, great use case for a, a, a, a simple flag.
- 5: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.
- 5:19
Now, an agent is not like an automation script. An automation script knows nothing. All of the decisions are pre-baked upfront. The agent can reason, it can 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
- 5:49
that with flags.
- 5:54
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 to what we need to do for agents, then the solutions become apparent. It's the same discipline with a new reader.
- 6:19
So here's the, here's the challenge: how might we keep the guardrails and the guidance and stop pretending that agents and humans have the same abilities? Now, I'm not gonna answer this question. That's the whole purpose of this workshop.
- 6:40
So here's the challenge. We've got a CLI, we call it Bris- Barista nine thousand. It's gonna take coffee orders,
- 6:51
and it's gonna fail when you try to run it from an agent because it's interactive.
- 7:03
And if you choose to participate in the challenge, the winner will win a Mac Mini. Walk, walk away with it today.
- 7:16
It's in that bag right there.
- 7:19
It's real.
- 7:20
That was a challenge in and of itself, getting a Mac Mini. I'll be straight up. Okay. Now, simple rules. We're going to give you a CLI.
- 7:35
You make changes to that CLI, run it through an agent, and it's gonna send some information up to our server, and then it's going to update a leaderboard. Now, we'll put, put the leaderboard up in a moment. We don't have two inputs, so we're gonna change the slide deck out for the leaderboard so you can see it. Now, here's Naveen. He's gonna talk you through this.
- 8:01
Thank you, Mark.
- 8:02
All right?
- 8:03
Yeah.
- 8:05
Cool. Yeah, uh, I think it's an exciting assignment for everybody, and this topic is very near and dear to me, but, uh, keeping things aside, Mark, are we getting any coffee after we build this?
- 8:22
I hope so. If we're successful.
- 8:25
Okay. Cool. Mm. So yeah. Let me, uh... Before we start into, um, the assignment, I wanna take to a journey, right? Uh, when I started my engineering career, I started to play with IDEs. I started to use Eclipse because I was primarily using Java, and as time went by, moved into IntelliJ, uh, JetBrains. It was amazing. Looking back
- 8:55
five or six years behind, uh, things started to evolve. There were new IDEs in the market, especially Microsoft VS Code, which gave birth to a lot of, uh, other IDEs as well.
- 9:11
So if you look right now, Microsoft had its own VS Code editor, but later on, new AI IDEs 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 gonna come back." But, you know, uh, I, I'd, I'd
- 9:41
actually like to say this Hangover movie dialogue that, um, you know, all, all the four friends are in the car and they say, "Hey, we are back." Imagine CLIs saying that to each other, and in the world of AI, they are actually back, right? Whoever bought it, yeah, I don't know. But the whole story is now the CLIs have changed, and who's responsible for that? Agents, right? So this workshop is
- 10:11
primarily focusing on agents, your CLIs, and this is gonna be a hands-on exercise. 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... Oh, maybe, uh, Vinod, if I can get the laptop. So we have couple of things. So we have... Yeah. Um,
- 10:41
so we have the repo, which is PayPal Cafe. It has the CLI that you can actually do- download. That's the bare bone CLI. Now, it's not gonna 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?
- 11:11
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 gonna get interesting with agents using the CLI, so think it from that perspective. Let me change this. I just change my laptops here.
- 11:36
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 fifteen or twenty minutes we'll share a good idea. Now, I'm not gonna call it a best practice. I'm just gonna call it a good idea.
- 12:07
Because I feel like we're early enough in the journey here where we don't know what the best practices are, and 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 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.
- 12:46
It's not working.
- 12:53
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 paypalcafe/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.
- 13:34
Okay.
- 13:53
Do we have the URL?
- 13:56
Use something else.
- 13:57
Oh, is it that one? Yeah.
- 14:00
We can do that one.
- 14:02
No. I think...
- 14:13
Yeah.
- 14:13
Hey, there you go.
- 14:14
Nice.
- 14:15
Sorry, I just stopped it.
- 14:20
Awesome.
- 14:20
Thank you.
- 14:21
Thank you so much. Hey.
- 14:26
Cool. Mm. 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 twenty-five to thirty minutes, um, and in between we'll interrupt with more slides and make it interesting.
- 15:12
Where's the laptop for the other slides? Vinod's got it? Okay. That's fine. No, no, no, you, you...
- 15:21
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:50
I'll tell a little bit, I'll tell a little bit about the models.
- 15:56
Don't use high models.
- 16:00
We-
- 16:03
Do you, do you want me to, you want me to say something?
- 16:10
You know, we had a, a little bit of a debate internally. There are some great models out there.
- 16:19
The interesting thing about this challenge, 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 wanna waste your high thinking tokens on running
- 16:49
a CLI tool. So the real challenge is can you make Haiku 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 wanna take it on.
- 17:16
Sounds fun. Yeah.
- 17:21
Awesome.
- 17:57
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?
- 18:09
I was not aware of that.
- 18:10
Oh, yeah. You should-
- 18:11
Go on.
- 18:12
Yeah.
- 18:12
Go on. Tell me more.
- 18:13
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.
- 18:25
Okay.
- 18:25
Yeah.
- 18:27
Any favorites?
- 18:28
Butter & Crumble. Yeah, my favorite one. Although I couldn't go there.
- 18:38
Awesome.
- 18:41
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 half?
- 22:10
Yeah.
- 22:40
Five
- 22:44
minutes.
- 22:45
Five
- 23:53
minutes,
- 24:00
okay.
- 24:18
Do
- 24:43
you want to know
- 24:47
?
- 24:47
I'll-- Once I plug it in, I'll put these things.
- 24:50
Okay.
- 25:39
Okay.
- 25:51
Wanna go ahead and-
- 25:52
Okay.
- 25:52
Here it is.
- 25:53
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 Tmux. How many of you know about Tmux here? Okay, quite a fair amount of audience out here. Um, so yeah, um, in short, start with running Tmux and, um, start by
- 26:23
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.
- 26:38
So...
- 26:45
Yeah. Send keys and capture pane gets you far. Now, Tmux 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 Tmux, and it's like a split pane, uh, feature that you could leverage with Tmux. 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.
- 27:16
Tmux-d. Now, what this flag does is it detaches the entire, uh, CLI and puts it under a different Tmux instance all together for you.
- 27:32
So, you could see size. Uh, Tmux capture pane, like I said, you could actually have split panes in Tmuxes, so you could actually take care of, um, working around with, um, in, in the CLI. And, uh, that's one of those cool features that can help your agents perform a lot of activities. Um, think of it when you want to run multiple agents,
- 28:03
you could actually spin up different sessions, and Tmux 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 communicate and start communicating when they have multiple sessions open, and these are some long-running tasks that you could actually run inside Tmux.
- 28:34
Second good idea is IPC side channels. So, like I mentioned before, Tmux was a good upgrade. So instead of doing screen scraping, which Tmux actually does, um, for visual in-intelligence, you could start using side channels. Now, side channels would help you define your arrow keys that you have and help you understand, and I'll go in the
- 29:04
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 agents want that. Since we have multiple personalities now, earlier we used to 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.
- 29:34
So side 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 interfe-- uh, interface. The API gives you a machine-structured interface, right? So think of side channel as exactly the same. Now, that's one of those analogies that I can refer.
- 30:06
Read state, send input as a data.
- 30:10
So we have the barista brew --hyphen, hyphen agent. Now, th-this is a command that will help you run- Your CLI with background agents, right? Um, you want your agents to be running in the background and, uh, you put all of these commands, they are gonna help you. Try using it in your current CLIs. See if you are able to, um, make some progress in
- 30:41
the Barista Brew 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 Brew ask, and then there is 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. So all you have to do
- 31:11
is feed in this input data so that agent actually knows that, and you gotta 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.
- 31:43
Same prompt with a different brain now. 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. 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.
- 32:28
You, you are actually 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 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,
- 32:58
and you can leverage this in the CLI that you are actually building. Try using it. Maybe you'll be on the highest on the leaderboard.
- 33:12
So we started a journey from Tmux, which is basically screen scraping to injecting skills.
- 33:24
So Tmux is low effort. I think a lot of you might have tried it, but this is where side channels also will help you in providing 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.
- 33:47
So yeah, keep pushing your scores.
- 33:54
Do you wanna show this now?
- 33:55
Yeah.
- 34:16
It does take some time.
- 34:17
There you go.
- 34:18
Okay. Cool. We do see a lot of traffic out here.
- 34:30
Oh, somebody's really close to five thousand. Is it Bang? Uh-
- 34:36
Hong
- 34:36
Hong. Okay.
- 34:53
Any questions so far anybody wants to get it answered? Any-
- 34:59
Over there
- 34:59
... queries? What happens if multiple people get five thousand points? Sorry. What happens if multiple people get five thousand points? Okay, let me repeat that question for you. What happens if multiple people reach a score of five thousand? Mark, you wanna take that?
- 35:19
So the, the idea was we would look at score, and if there's a tie, we would 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 a bunch of these that have completed it in zero seconds. So I need to consult with someone because that's
- 35:49
not supposed to be possible.
- 35:53
But the idea is that we would look at the high score, the, the score first, and then the time it takes to respond second, so that an accurate response returned quickly would be biased over an accurate response returned slowly.
- 36:28
D one for now
- 36:29
Okay. I'm sorry?
- 36:30
We have only one task to do, but eventually-
- 36:34
Yeah
- 36:34
... if they become under tasks, we might have to think about...
- 36:47
This is the bottom of the leaderboard. Nicholas, game up.
- 37:05
I think everybody has that zero second right now.
- 37:11
Yeah.
- 37:36
What time do you wanna end this?
- 37:39
A couple more minutes.
- 37:40
Let's wait two more minutes, and then we can open it up for ideas, and maybe do ten or twenty minutes of ideas according to how engaged they are.
- 37:52
Is that all right?
- 37:53
Yeah. Absolutely.
- 38:07
Did we have any?
- 38:27
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, 'cause I know that there's some out there.
- 38:58
Mark, were you expecting so many people to be in the four thousands?
- 39:03
Yes. Absolutely. At this conference?
- 39:06
Yeah.
- 39:06
Absolutely.
- 39:07
Awesome.
- 39:14
Were you not?
- 39:15
No. I was.
- 39:52
Okay.
- 39:52
What do you think, anybody can make it to five thousand?
- 39:58
I don't know. We'll hold it open.
- 40:02
Why don't we open the floor up now?
- 40:03
Yeah. For sure.
- 40:05
So 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?
- 40:21
Nobody wants to leave the desk.
- 40:35
Oh, we have... Yes.
- 40:37
It's, it's not an idea, but it's a very gameable benchmark because you only-- You really only have to fill, like, one order that has to be instant. So it's very easy to, like, crank up score without really doing better
- 40:53
Let me, let me come over to you because I can barely hear you.
- 41:04
Oh, sorry.
- 41:05
Okay.
- 41:09
Go ahead.
- 41:09
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 det- do a deterministic parser, 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.
- 41:33
Okay.
- 41:33
Which-
- 41:34
Is, is that what you did?
- 41:35
That's what I'm doing right now.
- 41:36
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 the reason is that if the CLI is a tool to be used by an LLM, then you
- 42:06
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 you don't want to build an agent into the CLI and then
- 42:35
hand that CLI off to another agent because you don't know what you're gonna get.
- 42:46
Any other interesting ideas? Obviously, we've-- s- a lot of people have figured out how to game the system.
- 42:55
Where there's a Mac Mini, there's a way, I guess. Yeah.
- 43:22
Mark, begin it. This, end this one, wait five minutes or-
- 43:27
Yeah, five minutes. The, the score hasn't changed in a while.
- 43:34
Before the site crashes.
- 43:42
Did you do refresh?
- 43:44
Yeah.
- 44:41
Why does it say reconnecting? Oh, there we go. Okay.
- 44:49
I think the network is a little laggy. The network is a little laggy out here.
- 44:54
Yeah.
- 44:58
There are a lot of com- a lot of computers.
- 44:59
Yeah. Sounds good.
- 45:02
Yeah.
- 45:02
It shouldn't crash.
- 45:35
Yeah, we're frozen right now.
- 45:44
Here we go.
- 45:47
Been no change in the results.
- 45:48
Yeah.
- 45:49
Okay.
- 46:11
Do we wanna wait a few more minutes or call it?
- 46:13
Yeah, like five minutes.
- 46:14
Five minutes. Okay.
- 46:17
Do you wanna bring the PPT to... PPT for the closing arguments or?
- 46:23
Yeah.
- 46:28
We're gonna give it about five more minutes. Yeah. And then we'll call it.
- 46:33
Where's Bon- where's Bonk? Raise your hand. Who is Bonk? Okay, we have something here. All right. Big smile, big smile.
- 46:44
And we do wanna 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.
- 46:53
The agent. That's why we're here, right? Um, no, I think what it-- what the agent ended up doing was building a deterministic solver, uh, to the CLI, which is normally deterministic. And then through, um, basically it has a skill. It already has a skill when you use this for multiple use cases.
- 47:15
Um, I need to go over here. Yeah. H-h-hold, hold on.
- 47:20
Sorry, I should have asked for another, I should have asked for another microphone for the room for questions.
- 47:30
Um, yeah. So Bonk is just the, an agent, uh, thing built on top of Claude 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 a, an environment and, um, optimize. So it basically ended up building a, uh, deterministic CLI solver, and then now it's just running on a tmux and slamming your APIs.
- 47:59
Okay.
- 48:00
Yeah.
- 48:00
All right.
- 48:01
Also, I think I got lucky because I hit it at one point at, like, twenty-nine milliseconds, uh, probably because we're in the same region.
- 48:10
Okay.
- 48:10
It's just a network latency.
- 48:11
Right. And this is all done on Claude?
- 48:13
Uh, Claude Agent SDK.
- 48:14
Okay.
- 48:15
I'm just driving it through Slack.
- 48:16
Now, which model?
- 48:18
Opus four dot eight.
- 48:19
Okay.
- 48:19
Yeah.
- 48:20
Did you try it with any other models?
- 48:22
For the build? Uh, for building the CLI or?
- 48:25
For r- for your a- for your agent, how would we do that? How would-
- 48:29
The, the CLI is completely deterministic.
- 48:31
Sure, sure, sure.
- 48:31
There's like no L- So the agent built the CLI and is just running it on tmux now.
- 48:36
Okay.
- 48:36
Yeah.
- 48:37
Awesome.
- 48:37
Yeah.
- 48:38
Congrats.
- 48:38
Thanks.
- 48:40
I'm gonna go to the next one. Danny. Who's Danny here?
- 48:51
We have one in the back.
- 48:58
You see him? He's back there. Thanks.
- 49:03
Last one.
- 49:12
What, what do we wanna know?
- 49:13
Yeah. How'd you build it? What was your technique?
- 49:16
Yeah. So I don't know anything about, uh, coding at all. I'm, I'm using, uh... I'm basically a vibe coder, and 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, Claude code up on, uh, VSC.
- 49:36
Have you ever built a CLI before?
- 49:38
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- "Uh, figure this out. Explain it to me like I'm, you know, like I don't know anything," and then-
- 49:51
Explain like I'm five?
- 49:53
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 we have, uh, two scripts running, and the first one got the, uh, forty-nine ninety-eight, and then I said, "Hey, make a copy and give me some suggestions for how we can get the forty-nine ninety-nine."
- 50:17
Right. Did you get any suggestions?
- 50:20
Uh, it's-- 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...
- 50:37
No, 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 the room who are just gonna point Claude or Codex at this and say, "Build a CLI. Make it fast. Make it deterministic." And those are the three ideas, right?
- 51:08
Yeah.
- 51:09
Okay. Do you wanna change the-
- 51:11
Yeah. Change the slide.
- 51:36
There it is.
- 51:37
Yeah. Okay. Uh, where was the...
- 51:53
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. Um, anything else before we close it out?
- 52:14
All right. There you go.
- 52:18
Takeaway for us, based on our instructions, our recommendations: give it good context, give it a side channel, and tell it to use Tmux.
- 52:30
Those are three-
- 52:32
Good ideas to start with.
- 52:35
Thanks, everyone. Monk, you wanna come on up?
- 52:40
We still have Monk as the winner, right?
- 52:41
Yeah.
- 52:42
Okay.
- 52:42
No, no. We called it. We called it five minutes ago.
- 52:44
Yeah, okay.
- 52:45
Yeah, yeah. I'm not gonna change, I'm not gonna change it.
- 52:48
Yeah.
- 52:48
We, we called it.
- 52:52
Monk. Whoo. Awesome.
- 52:58
You wanna take the-
- 52:59
Oh, that is-
- 53:00
Oh, yeah.
- 53:00
Oh, we do.
- 53:02
We'll get-- We'll just get a picture.
- 53:03
You, you get your-
- 53:05
You know, social media.
- 53:06
That's right.
- 53:14
It's a real Mac Mini.
- 53:16
It's a real Mac Mini? Oh my God, these exist?
- 53:20
All right. Awesome.
- 53:21
Okay, cool.
- 53:25
Where to come this-