Latest / Code Story | Startup Podcast for CTOs, CEOs and Technical Founders / S12 E12: The Rogue Agent Epidemic: Moving Beyond Laptop Prompts to Build a Centralized, Production-Grade AI Control Plane with Robert Brennan, Co-Founder & CEO of OpenHands

Transcript

S12 E12: The Rogue Agent Epidemic: Moving Beyond Laptop Prompts to Build a Centralized, Production-Grade AI Control Plane with Robert Brennan, Co-Founder & CEO of OpenHands · Code Story | Startup Podcast for CTOs, CEOs and Technical Founders

• 0:00
  [SPEAKER_00]: We're going to need a Kubernetes for Agents.
• 0:03
  [SPEAKER_00]: We're going to need a Linux for Agents, right?
• 0:05
  [SPEAKER_00]: There's good there'll have to be an open standard for how you define and drive and monitor these Agents at scale both within an enterprise and as an individual developer.
• 0:16
  [SPEAKER_00]: When I think open hands is the, or the largest open source project that has full end to end solution there.
• 0:23
  [SPEAKER_00]: It's not just a CLI, right?
• 0:25
  [SPEAKER_00]: It's all the cloud infrastructure you need.
• 0:27
  [SPEAKER_00]: It's all the, all those scalability things, all the sandboxing, et cetera.
• 0:31
  [SPEAKER_00]: All the security that I think is, I'd like to see open hands really become the standard there and have engineers all over the world trained on how to use open hands effectively.
• 0:41
  [SPEAKER_00]: I'm Robert Brennan, and I'm the CEO of Open Hands.
• 0:46
  [SPEAKER_01]: This is code story.
• 0:49
  [SPEAKER_01]: A podcast bringing you interviews with tech visionaries.
• 0:52
  [SPEAKER_01]: 6 months moonlighting goes.
• 0:54
  [SPEAKER_01]: I was lossing on the backhand.
• 0:55
  [SPEAKER_01]: Who share what it takes to change an industry?
• 0:58
  [SPEAKER_01]: I don't exactly know what to do.
• 1:00
  [SPEAKER_01]: It's all too many girls to get right.
• 1:02
  [SPEAKER_01]: who built the teams that have their bad company is its team's help each other, which is proud of our team.
• 1:09
  [SPEAKER_01]: Keeping scalability top of mind, all that infrastructure was up there.
• 1:13
  [SPEAKER_01]: Yes, we've been fighting it as we grew up.
• 1:14
  [SPEAKER_01]: Total waste of time.
• 1:15
  [SPEAKER_01]: The stories you don't read in the headlines.
• 1:18
  [SPEAKER_01]: It's not an easy thing to achieve.
• 1:20
  [SPEAKER_01]: To get yourself a deficit of off, try to begin to ride the ups and downs of the start-up line.
• 1:26
  [SPEAKER_01]: Need to really want it.
• 1:27
  [SPEAKER_01]: Not just about technology.
• 1:29
  [SPEAKER_01]: All this and more on code story.
• 1:32
  [SPEAKER_01]: I'm your host, Noah Labpart.
• 1:34
  [SPEAKER_01]: And today, a Robert Brennan is helping you scale from one to thousands of agents with an open platform for cloud coding.
• 1:54
  [SPEAKER_01]: He spent time in New York between the bookends, but he enjoys the chill pace and great music of Boston over the fast pace of the Big Apple.
• 2:02
  [SPEAKER_01]: Outside of technology, he likes to read non-fiction and fiction, specifically science fiction.
• 2:07
  [SPEAKER_01]: He loves music, and has been playing guitar for 25 years now.
• 2:10
  [SPEAKER_01]: He freaks the live music singing around Boston and even lives near a jazz club.
• 2:16
  [SPEAKER_01]: Robert observed the release of the first version of Devon a few years ago, which was very exciting to see Agent Driven development.
• 2:25
  [SPEAKER_01]: But he and his co-founders were concerned with, who was going to govern how this software was going to get written, and they hypothesized that it should be open source and community driven.
• 2:39
  [SPEAKER_01]: This is the creation story of Open Hands.
• 2:46
  [SPEAKER_00]: This is where we're working on an open source platform for AI driven development.
• 2:51
  [SPEAKER_00]: So every software engineer in the world right now is aware that AI is changing how we do our jobs.
• 2:55
  [SPEAKER_00]: And we saw that change starting to happen almost exactly two years ago.
• 2:59
  [SPEAKER_00]: I think big event there was a cognition release their demo video of David back in March of 2024.
• 3:05
  [SPEAKER_00]: And that was really the first time we saw an agent that was working on code.
• 3:10
  [SPEAKER_00]: It wasn't just a chat GPT inside of the chat window spitting out a function or something like that.
• 3:16
  [SPEAKER_00]: But we'd never seen AI that could actually run the code that it wrote.
• 3:20
  [SPEAKER_00]: And then ad debug statements to see what was going on Google and Aaron message that came out.
• 3:25
  [SPEAKER_00]: I basically do that whole interview with development until it got to a solution.
• 3:29
  [SPEAKER_00]: That was really exciting to see right it.
• 3:31
  [SPEAKER_00]: It's solidified and my imagination with the future of software development was going to look like.
• 3:36
  [SPEAKER_00]: But it was also a little scary that change was being pushed by the stealthy company coming out of a black box.
• 3:42
  [SPEAKER_00]: And it was very obvious to me and my co-founders that, you know, if the job of the software developer is going to be changing, the development community needs to say and how that change happened.
• 3:51
  [SPEAKER_00]: So we started a project at the time called Open Devon, now called Open Hands.
• 3:56
  [SPEAKER_00]: Really with the goal of making sure that the community is able to guide this change to how software gets written.
• 4:05
  [SPEAKER_01]: tell me about the indie piece that first version of the product to build, how am I going to take to build and what sort of tools we're using to bring it to life?
• 4:14
  [SPEAKER_00]: Yes, so my co-founder, I'm Graham Nubig, who as a professor at CMU, he was actually the first one to write some code in the open-devin repo.
• 4:22
  [SPEAKER_00]: And he created basically just an empty functionless front end that had a chat window and a terminal and a file editor.
• 4:30
  [SPEAKER_00]: I didn't really do anything yet, but it got people's imaginations going about, okay, what could this be?
• 4:35
  [SPEAKER_00]: But it got the community excited, right?
• 4:37
  [SPEAKER_00]: And everybody started contributing.
• 4:39
  [SPEAKER_00]: And then I came in and wrote the first, like, agent, which was basically like a long-framed and a four-loop wrapped around an LLM.
• 4:47
  [SPEAKER_00]: And that kind of got it.
• 4:48
  [SPEAKER_00]: So point where it was like functional, like you can do a thing.
• 4:51
  [SPEAKER_00]: I think my agents forward a 3% on sweet bench, which is how they test how good these agents are.
• 4:56
  [SPEAKER_00]: But it was enough to, like, get people's imaginations going, and then my, my third co-founder Shinyau, he came in, he was doing his whole PhD around co-generation and coding agents.
• 5:07
  [SPEAKER_00]: Right, so he was one of the top experts on this particular subject matter.
• 5:11
  [SPEAKER_00]: He came in, he threw away my agent, brought his own in, and immediately launched us to the top of the speed-bind sugar rates.
• 5:17
  [SPEAKER_00]: I forget what the numbers were.
• 5:18
  [SPEAKER_00]: I think at the time, it was something like 20% or 25% was state of the art or what percentage of the sweet bench coding problems could be solved then.
• 5:27
  [SPEAKER_00]: And that was like really exciting.
• 5:28
  [SPEAKER_00]: Like this was actually a useful agent.
• 5:31
  [SPEAKER_00]: We started using it occasionally on a day-to-day basis at this point.
• 5:34
  [SPEAKER_00]: And I think now we're at like 80% of that problem set being solved by today's agent.
• 5:39
  [SPEAKER_00]: So really huge lead from where we were in mid-2024 to today.
• 5:45
  [SPEAKER_01]: So you get to, you get to that point and you make those strides, right?
• 5:48
  [SPEAKER_01]: Like, you're describing, and you're getting the traction that you want, and you want to proceed.
• 5:54
  [SPEAKER_01]: How did you progress and mature it from there, and I'm curious about how, you built your roadmap.
• 5:58
  [SPEAKER_01]: How do you go about deciding that?
• 5:59
  [SPEAKER_01]: Okay.
• 6:00
  [SPEAKER_01]: This is the next most important thing to build, or to address with open hands.
• 6:05
  [SPEAKER_00]: But a really nice thing is we had just a ton of visibility with community, everybody.
• 6:11
  [SPEAKER_00]: swarmed on our repo and we're trying it and checking it out and giving us feedback and opening up issues, opening up polar quests, et cetera.
• 6:19
  [SPEAKER_00]: So we had a fire hose of feedback that we had us or through.
• 6:23
  [SPEAKER_00]: So it was really less about how do we imagine what to build next and more like how do we pair away all these requests that are coming in and figure out what are the most important ones, what are the most common pieces of feedback we're getting.
• 6:35
  [SPEAKER_00]: And I would say a roadmap kind of split into two two pillars.
• 6:38
  [SPEAKER_00]: One was like, how do we get this thing better at writing code?
• 6:41
  [SPEAKER_00]: How do we improve the quality of this thing so that it's useful, not just occasionally, but useful as a daily drive?
• 6:47
  [SPEAKER_00]: And it was by the end of 2024, was when it became my daily driver.
• 6:52
  [SPEAKER_00]: Like, I was something I was using every single day because I was shing now.
• 6:55
  [SPEAKER_00]: and the research team that we built with Shinyad Graham was really doing an amazing job of just making this thing better and better at solving coding problems, right?
• 7:03
  [SPEAKER_00]: They were figuring out ways to help it interact with a local file system to help it search through the existing codebase to help it manage its context window, all these like research oriented stuff to figure out how do you how do you have this thing better and better at writing code and coming into an existing codebase
• 7:21
  [SPEAKER_00]: Then the other half was really all about like developer experience, all about how do we make this you'll good for the developer who's actually piloting it?
• 7:28
  [SPEAKER_00]: And that was a more my side of the house on the product and developer experience side.
• 7:33
  [SPEAKER_00]: I've been working in an open source developer tooling forever over a decade now.
• 7:37
  [SPEAKER_00]: And that was a lot of just like looking through the comments, figuring out where people struggling with this setup, where people struggling with looking at their conversation history and understanding what are they doing, the running three or four different agents at once, how are they keeping track of that, how are they like responding when the agent gets stuck.
• 7:55
  [SPEAKER_00]: So there's a lot of that like more product oriented developer experience type of stuff was the second one.
• 8:02
  [SPEAKER_01]: Let's switch to team.
• 8:03
  [SPEAKER_01]: How did you go about building your team?
• 8:04
  [SPEAKER_01]: And I'm curious about what you'd look for in those people than the K that they are the winning horses to join you.
• 8:13
  [SPEAKER_00]: I think one of the nice things about being open source is that we actually had a huge community of developers who already contributed.
• 8:19
  [SPEAKER_00]: So one of our first hires was actually an open source contributor who we saw just doing great work inside of our repo.
• 8:26
  [SPEAKER_00]: And that we very quickly interviewed him and hired him and he's been just a great asset for us.
• 8:31
  [SPEAKER_00]: When we did put out job racks, we also had just a ton of interest because folks love open source.
• 8:36
  [SPEAKER_00]: They see that this is the future of software development.
• 8:38
  [SPEAKER_00]: They want to be a part of it.
• 8:40
  [SPEAKER_00]: I think they get really excited about building for themselves.
• 8:43
  [SPEAKER_00]: Right building a product that's going to make them more productive.
• 8:46
  [SPEAKER_00]: So we got just a ton of applications that like weeding through those resumes was really tricky.
• 8:51
  [SPEAKER_00]: But one of the things we did in our hiring process that has proven to be really great is any early days I was having folks to like a coding challenge in order to bet their technical skills and I was literally having them great code inside of a Google Doc.
• 9:03
  [SPEAKER_00]: So I could see how they think logically.
• 9:06
  [SPEAKER_00]: that's traditionally been the way that we test engineers is have them write code on a whiteboard or do some kind of care programming thing.
• 9:12
  [SPEAKER_00]: I had done some take home challenges in the past two where I was like, hey, go home and code up a little app and then show it off to us and take us through the source code.
• 9:20
  [SPEAKER_00]: But what we did is we actually switched to having folks use AI to write the code rather than making them write code by hand inside of a Google Doc, which is much closer to how people are working these days.
• 9:32
  [SPEAKER_00]: And that's been super, super successful.
• 9:36
  [SPEAKER_00]: What we do is we have folks record their screen for two to three hours and build an application from scratch using whatever tools that they want and they get a lot of leeway So if they're a front and engineer they can really focus on design and front and implementation things like that
• 9:52
  [SPEAKER_00]: If they're a more back-end oriented, they can focus on that, if they're more of a DevOps engineer, they can focus on the deployment strategy and CICD.
• 10:00
  [SPEAKER_00]: So if there is, you can take it anywhere you want.
• 10:02
  [SPEAKER_00]: There's a lot of creativity involved, and we get to see, how does this person think?
• 10:06
  [SPEAKER_00]: How do they problem solve?
• 10:07
  [SPEAKER_00]: And how do they use AI effectively to move faster?
• 10:10
  [SPEAKER_00]: When they can get a lot of none in a few hours with AI voting tools at their disposal.
• 10:16
  [SPEAKER_01]: Let's flip to scalability and this is in the bread and butter what you're building and how you're building in everything you describe with team and and I'm curious about how you approach thinking about scale from the beginning and there's been interesting areas where you still had to fight it as you've grown
• 10:34
  [SPEAKER_00]: I think scalability, at least in terms of the software and the platform we're building, that's always been a big piece of our vision here.
• 10:42
  [SPEAKER_00]: I think a lot of software developers today are used to running one agent locally, something that they're like pair programming with.
• 10:49
  [SPEAKER_00]: It's a very familiar workflow for developers where you pick up a ticket.
• 10:52
  [SPEAKER_00]: You like squinted your computer screen, open your IDE, figure out how I'm going to build this thing.
• 10:57
  [SPEAKER_00]: So now you've got an agent working alongside of you, helping you go maybe 20, 30% faster.
• 11:02
  [SPEAKER_00]: That's great, give the AI's giving you a good lift, but it's a very linear lift.
• 11:07
  [SPEAKER_00]: We've always been much more interested in what's going to be possible in the near future or you can get multiple agents working for each developer.
• 11:15
  [SPEAKER_00]: Maybe even dozens of agents working simultaneously, and the developer is more of an orchestrate, instead of focusing on agents that are running locally directly on your file system on your computer.
• 11:26
  [SPEAKER_00]: We've always been primarily focused on agents that are running each in their own sandbox, whether that's a Docker container running on your laptop or one running in like a Kubernetes spot in the cloud, and that allows you to run as many agents as you want or to each have their own area.
• 11:41
  [SPEAKER_00]: because they have a sandbox or not going to delete all the files in your hard drive or do something, you know, that's going to hurt your environment.
• 11:48
  [SPEAKER_00]: And they're also not going to step on each other's toes, right?
• 11:50
  [SPEAKER_00]: They each have their own copy of the code base, they each have their own file system, their own terminal, etc.
• 11:56
  [SPEAKER_00]: So there's a much more scalable way of working with agents.
• 11:59
  [SPEAKER_00]: And particularly if you're working on the cloud, now everybody on your team can run as many agents as they want.
• 12:04
  [SPEAKER_00]: You can run agents that aren't owned by any particular team member in the cloud.
• 12:08
  [SPEAKER_00]: It's a much more fun, much more scalable way of working with agents for doing.
• 12:11
  [SPEAKER_00]: Especially if you wrote maintenance and tech debt type work at scale.
• 12:16
  [SPEAKER_00]: Like making sure you're managing your dependencies, resolving vulnerabilities, adding type annotations, things like that.
• 12:22
  [SPEAKER_00]: It can really be done at another level of scale.
• 12:25
  [SPEAKER_00]: By working in the cloud and giving each agent its own sandbox.
• 12:28
  [SPEAKER_00]: Yeah, I think the other half of scalability is how we scale the company itself, and that's been a really interesting and fun problem for me to solve on the fly we've grown from maybe 13 people towards the end of last year to now we're up to 30 and it's been really interesting to watch how the culture changes and evolves as we scale up.
• 12:45
  [SPEAKER_00]: and making sure we're still being very rigorous with how we evaluate new candidates, making sure that they're not only technically very competent, but also align with our values, that they're kind people, that they are the sort of like highly open, highly agentic people that we want working at open hands.
• 13:04
  [SPEAKER_00]: I think that's going to continue to be a challenge as we do another doubling in the head cap.
• 13:10
  [SPEAKER_01]: Robert, as you step on on the balcony,
• 13:16
  [SPEAKER_00]: The thing that I feel really good about is our SDK.
• 13:21
  [SPEAKER_00]: It's called the software agent SDK.
• 13:22
  [SPEAKER_00]: We launched that towards the end of last year.
• 13:25
  [SPEAKER_00]: And it's the thing that when I look at it, it's very clear to me that this is a best in class offering.
• 13:29
  [SPEAKER_00]: It's completely differentiated with anything else that's on the market.
• 13:32
  [SPEAKER_00]: and what's really cool about it is that we're seeing both individual developers and brand new startups and like very big companies with like tens of thousands of engineers building on top of this SDK to create brand new developer experiences.
• 13:47
  [SPEAKER_00]: So essentially the genesis of this SDK was if we had this monorepo, the open hands get every bow, where we just accumulated a bunch of code over the course of about a year and a half.
• 13:57
  [SPEAKER_00]: through the open source community.
• 13:58
  [SPEAKER_00]: We have 500 or so contributors in our ecosystem and this code base just grew into this spaghetti monster of code and out of front end, back end, there was a CLI, there was all the agent code for actually solving these software problems.
• 14:12
  [SPEAKER_00]: And we'd made this very hard decision.
• 14:13
  [SPEAKER_00]: Towards the end of 2025, the hey, like we need to, we need to pause and factor out all of the agent code into its own place.
• 14:22
  [SPEAKER_00]: And that became the software agent SDK.
• 14:24
  [SPEAKER_00]: So all of the code around one of the prompts that we're using to drive this thing forward, how is it interacting with the file system, how is it interacting with terminal, how is it getting sandboxed, what's that like agent loop like, how is it managing its context window, our security analyzers, basically everything you need to run a software agent goes into this software agent SDK.
• 14:45
  [SPEAKER_00]: And then the front end and our GitHub integration or Slack integration, our CLI, I'll become consumers of this SDK.
• 14:53
  [SPEAKER_00]: So those are, like, more, though, like, last-mile developer interfaces.
• 14:57
  [SPEAKER_00]: But the SDK now contains basically everything you would need to build, uh, a gented developer experience.
• 15:02
  [SPEAKER_00]: And we've seen one large, public company that is built, like an internal, vibe-coating platform for their customers to let their customers take advantage of their technology, so they're forward to play it engineers now use this on a daily basis to help their customers write code that interfaces with their systems.
• 15:19
  [SPEAKER_00]: I was super cool to see.
• 15:20
  [SPEAKER_00]: There's a small, like, lovable competitor that's coming up now.
• 15:25
  [SPEAKER_00]: They just got their seed round.
• 15:26
  [SPEAKER_00]: They're building on top of the open hands SDK in order to power there by putting platform.
• 15:31
  [SPEAKER_00]: We're seeing I've built my own developer workstation using the open hands SDK.
• 15:35
  [SPEAKER_00]: Just this is how I want to work.
• 15:37
  [SPEAKER_00]: It really gives you all the nuts and bolts of the Lego bricks you would need to build whatever kind of developer experience you want that would be powered by agents.
• 15:47
  [SPEAKER_01]: Okay, let's flip the script a little bit.
• 15:48
  [SPEAKER_01]: Tell me about a mistake you made and how you and your team responded to it.
• 15:53
  [SPEAKER_00]: Yeah, I would say playing off that same theme.
• 15:56
  [SPEAKER_00]: We went way too long just building up tech debt in this monorepo.
• 16:00
  [SPEAKER_00]: Right, I think one of the tricky things about having a popular open source project is that you're constantly getting contributions from the community.
• 16:06
  [SPEAKER_00]: These contributions are often from folks who aren't fully familiar with the code base.
• 16:12
  [SPEAKER_00]: They might introduce some redundancy, they might introduce some subtle bugs.
• 16:16
  [SPEAKER_00]: we were getting just overwhelmed with code review.
• 16:19
  [SPEAKER_00]: That's actually become a harder problem today in the AI driven era because it becomes really cheap for folks to open up a full request, right?
• 16:26
  [SPEAKER_00]: They're like, I would love a bit bucket integration and they just ask open hands to do it.
• 16:30
  [SPEAKER_00]: And open hands generates a bunch of code and they might give it a cursory glance.
• 16:34
  [SPEAKER_00]: They might not look at it at all.
• 16:35
  [SPEAKER_00]: They might not even run the code to make sure that it works and they open up a full request.
• 16:39
  [SPEAKER_00]: That's on us to make sure it works, get it merged.
• 16:41
  [SPEAKER_00]: and that because we were getting all of these polar quests, we were doing our best to do code review and validate them, but we ended up with this very big hairy code base with a lot of tech debt that accumulated over time.
• 16:54
  [SPEAKER_00]: And I think it took us a little too long to, like, finally, just like decide, hey, we need to break this thing up.
• 17:00
  [SPEAKER_00]: We need to spend a couple of months just like paying down a bunch of tech debt, ripping out this, obviously trying to separate concerns of this
• 17:11
  [SPEAKER_00]: So I wish we'd architected things a little bit more cleanly in the beginning so that they'd really clear separations of concerns.
• 17:23
  [SPEAKER_01]: Okay, let's move forward then.
• 17:25
  [SPEAKER_01]: What does the future look like for open hands?
• 17:27
  [SPEAKER_01]: The industry is changing your view.
• 17:30
  [SPEAKER_01]: Primed and ripe and ready to go, take on the world.
• 17:33
  [SPEAKER_01]: What does the future look like for the product and for your team?
• 17:38
  [SPEAKER_00]: Yeah, I think I'll start by talking about the future of software development looks like because that's really what we're trying to create.
• 17:44
  [SPEAKER_00]: I think today we're just seeing the first innings of how large language models are changing the software developers experience.
• 17:52
  [SPEAKER_00]: I think we started with just like tab completion, which was very familiar to developers.
• 17:56
  [SPEAKER_00]: We've been using auto-complete for decades and just got a million times better when powered by LOMs.
• 18:00
  [SPEAKER_00]: I think we pretty quickly graduated to these like local agents working on your laptop as like a paraprogrammer where we really see the future is agents that are running in the cloud with their own sandbox and running multiple agents per developed, getting a lot more done than you can in a more paraprogramming model.
• 18:17
  [SPEAKER_00]: and I think that's really the future we're trying to build.
• 18:20
  [SPEAKER_00]: I would say we've always been the edge of what's possible, working mainly with the early adopters, rather than trying to play for the median developer, and I would say the trade-off being we're doing less work to meet the developer where they live today, like inside their IDE and on the CLI, and we're doing a lot more work to help the early adopters really plot out what the future of software development looks like.
• 18:43
  [SPEAKER_00]: So yeah, I think if our plans come to fruition, and my wildest dreams come true, open hands becomes essentially the open source standard for how you run these agents at scale and production.
• 18:56
  [SPEAKER_00]: We're going to need a Kubernetes for agents.
• 18:59
  [SPEAKER_00]: We're going to need a Linux for agents, right?
• 19:02
  [SPEAKER_00]: There's got to be an open standard for how you define and drive and monitor these agents at scale, both within an enterprise and as an individual developer.
• 19:12
  [SPEAKER_00]: And I think open hands is the, or the largest open source project that has full end to end solution there.
• 19:19
  [SPEAKER_00]: It's not just a CLI, right?
• 19:21
  [SPEAKER_00]: It's all the cloud infrastructure you need.
• 19:23
  [SPEAKER_00]: It's all the, all those scalability things, all the sandboxing, et cetera.
• 19:27
  [SPEAKER_00]: All the security that I think is, I'd like to see open hands really become the standard there and have engineers all over the world trained on how to use open hands effectively.
• 19:39
  [SPEAKER_01]: Okay, Robert, let's flip it to you.
• 19:42
  [SPEAKER_01]: Let's wish you who influences the way that you work.
• 19:45
  [SPEAKER_01]: Name a person or many persons or something.
• 19:47
  [SPEAKER_01]: You look up to him.
• 19:47
  [SPEAKER_01]: Why?
• 19:49
  [SPEAKER_00]: I get my most of my inspiration just from watching the engineers on the open hand steam work and seeing what they're doing and how they're being productive.
• 19:58
  [SPEAKER_00]: We've built a really strong team of very smart people who are also very forward thinking and very willing to experiment.
• 20:06
  [SPEAKER_00]: Just this morning I was looking at my co-founder Graham, shared with me his like daily workflow for making progress on his work with agents.
• 20:15
  [SPEAKER_00]: Archmarch down via with me.
• 20:17
  [SPEAKER_00]: Basically describes this whole workflow to an agent so that the agent can help him execute on this workflow.
• 20:23
  [SPEAKER_00]: just seeing how he works and how he is pushing, pushing the envelope with like how how he works with agents.
• 20:30
  [SPEAKER_00]: He's at the bleeding edge of what's possible here.
• 20:32
  [SPEAKER_00]: He's not only about a company that's at the forefront here.
• 20:35
  [SPEAKER_00]: He's been working on co-gen for over a decade within academia.
• 20:38
  [SPEAKER_00]: So he's like very well at soon to what's possible here.
• 20:41
  [SPEAKER_00]: Like he's been a huge inspiration for me in terms of pushing out the art of the possible when it comes to agents.
• 20:50
  [SPEAKER_01]: Robert last question, so you're getting on a plane and you're sitting next to a young entrepreneur who's built the next big thing.
• 20:56
  [SPEAKER_01]: They're jazzed about it and I can't wait to show it off to the world and can we show it off to you right through on a plane?
• 21:00
  [SPEAKER_01]: What advice do you give that person having gone down this road a bit?
• 21:03
  [SPEAKER_00]: I think the biggest thing is just enjoy the ride, right?
• 21:06
  [SPEAKER_00]: It's easy to get caught up and plotting out the end game and figuring out what am I going to do with my billion dollars once I exit or what's it going to feel like when we've got however much in revenue and however many engineers those early days are the most fun days.
• 21:20
  [SPEAKER_00]: I think as much fun as I'm having with open hands today as a team of 30 and starting to scale up revenue and all that, the most fun I had was in those early days was first like six weeks of,
• 21:30
  [SPEAKER_00]: uh, prototyping and working with the community and before we even raised our first round.
• 21:35
  [SPEAKER_00]: It's just such an exciting time when you know you've got something really special and valuable on your hands and so making sure you're enjoying the ride rather than getting overly focused on the destination I think is very important.
• 21:46
  [SPEAKER_01]: Couldn't agree more, that's fantastic advice.
• 21:49
  [SPEAKER_01]: Robert, thank you for being on the show today.
• 21:50
  [SPEAKER_01]: Thank you for telling the creation story of Open Hands.
• 21:53
  [SPEAKER_01]: Yeah, thank you for having me.
• 22:06
  [SPEAKER_01]: code story is hosted and produced by no-alapart.
• 22:09
  [SPEAKER_01]: Be sure to subscribe on Apple podcast, Spotify, or the podcasting app at your choice.
• 22:15
  [SPEAKER_01]: And when you get a chance, leave us a review.
• 22:17
  [SPEAKER_01]: Both things help us out tremendously.
• 22:22
  [SPEAKER_01]: And thanks again for listening.