Marimo Pair - A Canvas for Agent + Developers Collaboration

00:00 Coding agents have gotten really good at one kind of work.

00:03 You scope a feature, edit some files, run the test, ship it.

00:07 It all happens on disk.

00:08 But that is not how data work feels.

00:11 You load something, you look at it, you run a cell, you watch how it responds,

00:14 you decide the next move from whatever is sitting in memory.

00:18 And until now, your agent couldn't see any of that.

00:20 They only saw files, never the live state.

00:24 On this episode, that wall comes down.

00:26 Marimo pair drops a coding agent right inside a running notebook with full access to every variable Python is holding in memory.

00:33 The notebook becomes a shared canvas.

00:35 You point, it runs the code.

00:38 You tell it to zoom in on a graphic and the chart just updates.

00:41 No MCP tools to wire up, no schema to describe, just Python and an agent that can finally see what you see.

00:49 Trevor Manz from Marimo is back to walk us through it.

00:53 This is Talk Python To Me, episode 555, recorded June 30th, 2026.

01:17 Welcome to Talk Python To Me, the number one Python podcast for developers and data scientists.

01:22 This is your host, Michael Kennedy.

01:24 I'm a PSF fellow who's been coding for over 25 years.

01:28 Let's connect on social media.

01:30 You'll find me and Talk Python on Mastodon, BlueSky, and X.

01:33 The social links are all in your show notes.

01:36 You can find over 10 years of past episodes at talkpython.fm.

01:39 And if you want to be part of the show, you can join our recording live streams.

01:43 That's right.

01:43 We live stream the raw uncut version of each episode on YouTube.

01:47 Just visit talkpython.fm/youtube to see the schedule of upcoming events.

01:52 Be sure to subscribe there and press the bell so you'll get notified anytime we're recording.

01:56 This episode is brought to you by Sentry.

01:59 You know Sentry for the error monitoring, but they now have logs too.

02:02 And with Sentry, your logs become way more usable, interleaving into your error reports to enhance debugging and understanding.

02:10 Get started today at talkpython.fm/sentry.

02:14 Trevor, welcome back to Talk Python.

02:16 Great to have you back.

02:17 Yeah, thanks for having me again.

02:19 We'll probably talk about notebooks, data science, maybe a little bit of AI in the mix.

02:24 Yeah, definitely. We've been doing a lot at Marimo and thinking about how agents can play nice with notebooks.

02:30 I think it's a little bit of an extra challenge, so it's going to be fun to see what you all have in mind.

02:35 Now, before we get into that, it's been a year since you've been on the show to talk about AnyWidget.

02:40 Just give us a quick introduction for folks who maybe didn't listen to that episode.

02:43 Yeah, AnyWidget is both a specification and a toolkit for making interactive UI elements

02:50 that deeply integrate into your interactive programming environments,

02:54 and specifically Python environments.

02:56 It has deep integration into Marimo, which is the company that I work at now,

03:00 where we build a new kind of reactive Python notebook.

03:03 I'm a fan of Marimo. I don't do that much stuff in notebooks,

03:06 but if I did, I would be using Marimo most of the time.

03:09 It's kind of like that Dos Equis.

03:11 Yeah, yeah.

03:13 I like to, depending on the ilk of user that we have, I like to make the joke that there are often

03:19 a certain group of folks that have plenty of notebook friends

03:24 but don't really use notebooks themselves.

03:26 And I'd like to at least pitch why I think Marimo scratches the itch of many more software developers

03:31 and represents more traditional software than traditional computational notebooks.

03:37 I think it also kind of is special for people We were more on the software development side because it's a little more Python focused instead of special tool focused in that.

03:47 We'll talk about Marimo in a second.

03:49 But like, for example, instead of having IPY and B files, it has just Python files.

03:54 Yeah, we are hyper focused on Python.

03:56 So we're from all the way from the, you know, our file format down to the way that we understand the relationships between yourselves.

04:04 It's all oriented around the Python ecosystem.

04:07 Yeah, that's probably going to pay off a little bit when we talk about this project here.

04:10 Yeah, definitely.

04:12 Definitely.

04:13 All right, well, actually, let's do a quick refresher on just what Marimo is.

04:19 Am I saying that right?

04:19 Marimo?

04:20 Sorry, I should be saying Marimo, right?

04:21 Yep, it's Marimo.

04:22 Yep.

04:23 Okay.

04:24 Give us a quick refresher for people who don't know.

04:26 You know, it's sort of in the realm of JupyterLab, but also different.

04:30 Yeah.

04:31 Marimo is spiritually a computational notebook, much similar to something like Jupyter or Google

04:36 Colab, if folks have used that before.

04:38 But as we just mentioned earlier in the show, we're hyper-focused on the Python ecosystem.

04:43 And we are also a special kind of notebook in that we are a reactive Python notebook.

04:49 So what that means is that the order in which Marimo understands your notebook is not in the

04:55 order that you wrote the cells, but the actual data flow between the cells.

04:58 And so we understand the relationships between your cells based off of the variables they

05:03 declare and where those variables are used.

05:05 And then we know how to automatically re-execute the notebook to ensure that you don't get to some sort of inconsistent state in your notebook.

05:11 So you can really think of Marimo as you are incrementally building a Python program rather than sort of a scratch pad or a set of logs of like some code that ran.

05:19 It sounds like a minor feature, this reactive bit, but it's not so minor.

05:24 I'll tell you what, like I'm sure people who've done a lot of work with notebooks have had the experience where they're iterating, iterating, going back, editing, making changes.

05:33 and maybe go back three cells, edit something, rerun that cell,

05:37 go down back to where they were and continue.

05:39 Like, why is this?

05:40 It doesn't seem to do anything.

05:43 Or this is not what I expected or whatever.

05:45 And then you realize, oh, because I didn't run the two cells

05:49 or the one cell in the middle that actually used that value,

05:52 which then flowed on to the next, right?

05:54 And basically what you're saying with this Reactive Notebooks

05:57 is unless you overwrite it or something, that can't happen with Marimo.

06:01 Yeah, it's essentially when you're working something like a Jupyter notebook,

06:05 you, the user, have to do a form of bookkeeping to make sure that whatever state exists in the kernel

06:11 is representative of whatever cells you have on the screen.

06:14 And discipline doesn't really scale necessarily, or it becomes hard to do that bookkeeping yourself.

06:20 Come on, I don't buy it because look, when you go into Jupyter, it says like 27, 34, 57, 58, and then 90.

06:30 And if you see one of those, if you're not doing your bubble sorting,

06:32 that's out of order. You know you've got to go back and run it. I mean, we all keep track of this.

06:37 Yeah, but essentially the moment that you get to some sort of complex notebook and state,

06:43 that becomes a lot of cognitive overhead that you as the user sort of have to keep in mind in order

06:48 to ensure that what you're doing is representative, such that when you hand off your notebook to

06:52 someone else, they're able to confidently reproduce that execution that you had in front of you and get

06:57 back to that state. And so with Maremo, we offload that.

06:59 It's just about that, right?

07:00 Like that's obviously a problem.

07:02 Yeah.

07:03 And so at Marimo, you essentially offload that bookkeeping to a system,

07:07 which we do this dependency tracking of your variables and where they're declared and where they're used.

07:13 And essentially we can provide guarantees that if you try to do something like

07:16 rerun a cell, we will rerun all descendant cells of that cell.

07:20 Or if you try to redeclare a variable, we'll tell you, hey, you already declared this variable and eliminate this problem of hidden state.

07:27 such that when you do end up working on a team with more than one individual

07:30 and you want to hand off that artifact to someone, they can confidently run the notebook

07:34 and reproduce the execution results that you were looking at

07:38 when you ran that notebook earlier.

07:40 Yeah, it pretty much guarantees ordering.

07:42 Yep.

07:42 Okay.

07:43 Also, it's got a really nice modern UI feel, I think.

07:49 It looks good.

07:50 It feels fresh.

07:51 And I don't know, for some people, maybe that doesn't matter.

07:54 But to me, I'm working on stuff.

07:56 I just feel better if it's a nice UI and it looks polished instead of old school.

08:01 Yeah, and because we are hyper-focused on the Python ecosystem,

08:05 we've been able to think about common data structures and objects that are in the Python ecosystem

08:10 and then really have polished user experiences for inspecting and understanding those objects.

08:14 So inside of a Marimo notebook, if you load a data frame, whether that's a Polars data frame

08:18 or a Pandas data frame or an IBIS table or anything that implements this data frame protocol,

08:24 which is a standard in the Python ecosystem, we can represent and render

08:28 in a really nice interactive table.

08:30 And so we're able to do that because we're tailored around this Python ecosystem

08:34 and we're able to polish both the user experience on the front end side

08:38 as well as all the way down to the kernel in terms of being able to share

08:42 these reproducible notebook documents.

08:44 Okay, yeah, I love it.

08:46 All right, so that's Marimo.

08:47 And what we're talking about today is not exactly Marimo,

08:51 but more AI plus notebooks in a particular tool, agent skill.

08:56 I don't know.

08:57 We're going to get into that, what it is.

08:59 But before we do, let's just talk about how do people,

09:03 like what do people do with, say, either Marima or Jupyter or JupyterLab today

09:10 without a tool like Marima pair?

09:12 Yeah, I'd say that the software as I've known it over the past year

09:16 has changed quite a bit for traditional software development.

09:19 And as we started working more and more on Marimo, we were using agents to perform more of our traditional software development.

09:27 And many of our users were asking, what's the best way to use Marimo with agents?

09:31 Because they've been using Marimo.

09:33 And I think that many different, if you'd ever tried out of the box to use one of these coding agents with notebooks,

09:40 whether it be Marimo or JupyterLab or Jupyter or Google Colab,

09:46 there kind of felt like this difference or like awkwardness in that user experience in terms of

09:51 being able to drive that interactive environment in a way that I think was very sort of unsettling

09:57 or unfulfilling compared to traditional software development because you're able to sort of like

10:02 put off your agent on these long-lived software tasks and then come back and have it run the test

10:07 and let it get in these type loops to be able to autocorrect and do this sort of like traditional

10:13 programming and software development.

10:15 But when you tried to apply it to a data problem, things would happen where you edit the file

10:20 and then you could get to some inconsistent state inside the notebook,

10:24 or the agent couldn't actually see the actions that it performed inside that notebook.

10:27 And it wasn't really able to get inside those tight loops.

10:30 And so we really started thinking from the bottom up, how can we open up Marimo in such a way

10:35 that it's actually useful to an agent rather than just this data source that it can query

10:39 and really try to extend that agent's working environment with notebooks the same way that,

10:45 you know, humans have used notebooks for working on data tasks.

10:49 I think notebooks are particularly tricky for AI to work with because many people know,

10:55 but probably not everyone.

10:57 When you look at a Jupyter notebook, the IPY in B file, you've got your cell definition

11:03 with code or markdown or whatever's in there.

11:06 But also, and this is the part that makes it tricky part of the part, is that all the output.

11:11 So if you've got something that lists out a thousand rows, that's just embedded in the JSON that defines that notebook file, right?

11:21 And so as a Claude Code or a codex or whatever that's going to go through and try to understand it,

11:26 it's got to skim through all of that output, determine most of it is irrelevant to me.

11:31 Some of it is relevant.

11:32 Maybe it was run in the wrong order.

11:34 So if it does try to look at the output, it's actually, right, there's no enforcement of an order.

11:37 And so if it's run in the wrong order, the output might be present and they might want to use it,

11:43 but it's actually wrong because it was run, it's stale from what's actually in there.

11:47 There's a lot of issues, right, to just work directly on the file format.

11:51 Yeah, I think, you know, as we started thinking about this problem, I think that we, you know,

11:56 even ourselves at Marimo started to realize that for notebooks, these file formats are more the

12:00 artifact of the work rather than the source necessarily of the code. And really, it's the

12:07 editor combined with the state, which is how you are authoring these notebooks in this live,

12:12 interactive environment. And that by just allowing agents to use their tools out of the box and edit

12:17 those artifacts on disk, they're missing a lot of the context in which those files are actually

12:24 authored. And they're also, in what you just mentioned, they are polluted with additional

12:28 context that's not necessarily useful to like performing a coding task on behalf of the user.

12:33 Yeah, it's like, hey, Claude, work on this. And by the way, here's 10,000 lines of stuff that may

12:37 either help you or harm you depending on stuff you can't determine really.

12:41 Yeah, exactly. So I think we started to think about this as more, you know, humans, like,

12:48 you know, out of the box, these coding agents are equipped with sort of like the ability to read

12:52 and write files and run bash scripts. And those tools really fit like the tasks of traditional

12:57 software development because that type of like the way that our command line tools and work that we

13:01 do for traditional software development work or that the file system is really the source of truth

13:07 and then you like make changes to those files and then you run sort of these like stateless commands

13:11 that like run your tests or basically take those changes and apply them and see if like what effect

13:16 that those have had and humans you know for data tasks have have sort of gone beyond the tools of

13:22 reading and writing and editing files and running batch scripts and instead we use these really like

13:27 interactive repls or sort of live programming environments for working with data because they

13:31 give us this ability to like iterate on intermediate results and values. So it's not like you run a

13:37 script, maybe you made an error, you have to run that script again from scratch. Instead, we can

13:40 like load a data set into memory and then sort of inspect those values and sort of iterate on them

13:45 in memory. And so like the usefulness of those sort of interactive environments like Excel or

13:51 Jupyter or Marimo or even something like RStudio is that they're stateful. And one problem is that

13:58 these agents weren't really good at accessing those stateful environments. And so that's exactly what

14:05 made it hard for us to open up those environments to agents. And I think there are many different

14:09 approaches that folks have taken. And even we took originally to try to make Marimo a useful tool.

14:14 And it took us a little while to figure out what were the ergonomics that work well for agents.

14:19 Sure. So what you're saying is basically, instead of running on the file system,

14:25 like the coding agents do now for, say, my code, I guess,

14:29 what instead they need is they need to run in the kernel,

14:32 kind of looking at the state of things in the kernel as it's working

14:36 more than, say, regular programming code.

14:39 Exactly. Yeah. Because, you know, when we, as humans have adopted these tools,

14:43 the reason we adopt them is because it's not just the code,

14:45 it's the values and the in-memory representations of those data

14:49 So it's not just that I have this data frame on disk or this file on disk that has my data,

14:55 it's that I want to look at the table and I want to see what those values are. And that may determine

14:59 the next step that I'm going to take with that data of what plots I'm going to do or what validations

15:04 I'm going to run on these data. And so really we had to sort of invert that thinking and think more

15:09 about how do we extend these agents with a useful tool, which is a notebook for doing this sort of

15:15 data work and iterating on those intermediate values.

15:20 This portion of Talk Python To Me is brought to you by Sentry.

15:22 You know Sentry for their great error monitoring, but let's talk about logs.

15:27 Logs are messy.

15:28 Trying to grep through them and line them up with traces and dashboards just to understand

15:32 one issue isn't easy.

15:34 Did you know that Sentry has logs too?

15:37 And your logs just became way more usable.

15:39 Sentry's logs are trace connected and structured, so you can follow the request flow and filter

15:44 by what matters. And because Sentry surfaces the context right where you're debugging, the trace,

15:50 relevant logs, the error, and even the session replay all land in one timeline. No timestamp

15:55 matching, no tool hopping. From front end to mobile to back end, whatever you're debugging,

15:59 Sentry gives you the context you need so you can fix the problem and move on. More than 4.5 million

16:05 developers use Sentry, including teams at Anthropic and Disney+. Get started with Sentry

16:10 logs and error monitoring today at talkpython.fm/sentry. Be sure to use our code talkpython26.

16:17 The link is in your podcast player show notes. Thank you to Sentry for supporting the show.

16:22 Maybe good time to introduce Marimo pair. What is this? Yeah, so Marimo pair is an agent skill

16:30 that drops an agent inside of an active Marimo kernel. And it allows basically it's a single tool

16:36 that allows the agent to run Python code inside of that kernel

16:39 to inspect and perform any sort of understanding what sort of intermediate values you have

16:44 inside of your kernel environment, but then also drive the authorship of the notebook itself

16:48 and run and execute cells.

16:50 So basically it allows the agent to do anything you could do in a Marimo notebook

16:55 and extend your analysis with an agent by giving the agent the ability to drive the exploration

17:02 of a Marimo notebook.

17:03 Interesting.

17:04 Okay, so how does it get inside the notebook?

17:07 You know what I mean?

17:07 Do you have to change your code or something like that?

17:11 Do you have to include something?

17:13 Yeah, so the setup is essentially an agent skill that you can install either from,

17:17 if you're using something like Claude Code, you can install it from the Cloud Marketplace.

17:20 You can install from Codex from a Marketplace as well.

17:23 Or you can use an NPX command to install a skill from GitHub.

17:28 And that skill teaches the agent how to use a single tool,

17:31 which is essentially just run Python.

17:34 And that single tool call allows the agent to run any kind of Python it wants to in the running Marimo kernel.

17:40 So inside that kernel environment, it can do things like list variables that are in the notebook.

17:44 It can inspect the cells of the notebook and look at the outputs of the notebook.

17:48 But then it can also perform sort of user tasks in the notebook as well, like installing packages inside of Marimo or creating cells or running cells.

17:57 But as it's performing those tasks using that tool, the agent gets instant feedback of what went wrong or what went right inside of that kernel.

18:04 and is able to get back into these agentic loops for doing these tasks.

18:08 But using Marimo as sort of the workspace for performing your data tasks

18:11 rather than editing the file system.

18:14 Yeah, okay, that makes sense.

18:15 And I guess there's some kind of API or something that the agent can use to talk to the running notebook.

18:21 Yeah, so we sort of hide an API within Marimo that's called code mode.

18:27 And what code mode is essentially is this semi-private API

18:30 that's just meant for agents that are running Python inside of that kernel.

18:34 And with that API, the agent can grab the current notebook state

18:38 and talk to Marimo directly.

18:40 So it can do things like toast notifications in the UI that say,

18:43 hey, I'm connected to your notebook session.

18:46 It can do things like I mentioned before, like list out variables or inspect what cells declare different variables.

18:53 But then also it has these sort of mutation APIs where I want to say create cell, edit cell, run cell.

19:00 And because it's all Python and not individual something like MCP tools,

19:05 the agent has the ability to write Python code that really does complex composition of those primitives as well.

19:11 So it can create multiple cells at the same time just by calling create cell five times inside of some sort of loop.

19:18 Because we're giving it Python as the tool rather than sort of a JSON API.

19:22 I'll say, for me, it kind of boggles the mind how much Claude Code just relies on grep to understand projects.

19:30 And it seems super inefficient to me.

19:33 I mean, Claude Code was created in two weeks, something like that.

19:37 It feels very much JavaScript-y in that regard.

19:40 Like, look what you built.

19:42 Also, look at the missing pieces a little bit.

19:44 And as impressive as it is, it seems like if it could ask the question,

19:50 where is this symbol used throughout my project?

19:53 What is the value of this variable?

19:55 Things like that.

19:55 What is the type of it?

19:57 Without reading and jumping around 100,000, a million lines of code all the time, it would

20:03 be way more efficient.

20:04 And it sounds a little bit like that's how it interacts with your notebook through Marimo

20:07 Pair.

20:08 Yeah.

20:08 So within that code execution point where it can run Python code, the agent has the ability

20:13 to look at the source of those cells, but then also can look at the in-memory values

20:18 of those cells as well.

20:19 And therefore, it can, like you were just saying, it can look at the type, it can look at the

20:24 values.

20:25 and this type of runtime inspection of values really does change model behavior

20:31 in terms of, like I mentioned before, allowing them to get into these loops

20:36 and efficiently get to some sort of problem, resolution to some task or problem inside the notebook

20:41 because it's able to course correct and ask a lot richer information about your values.

20:46 Because if you're looking at a source code on disk, maybe for a file that loads a data frame,

20:51 you just have a single line that says, you know, load, Polars read CSV or pandas read CSV.

20:57 And then the agent would actually have to go look at that CSV to understand what's in that CSV

21:02 and combining that with the source code.

21:04 But if you pair that with a live REPL like we have inside of Marimo,

21:07 the agent could just say, you know, the agent now has a data frame that it can look at.

21:11 And that's a much richer representation of that static file on disk.

21:15 And then the agent can ask about the schema.

21:17 It could ask about, yeah, the different columns, the data types of the columns.

21:20 It could figure out the number of rows.

21:23 So essentially when you ask a question of, you know, I want to plot the quantitative axes of these data in a pair plot, you no longer have to specify what those axes are because the agent can just go off and look at the schema to figure that out.

21:35 And I think that that provides this really rich experience when you're trying to get something done with your data because you can be a little bit more declarative about like, I want to look at these subsets or these things without having to actually go down and figure out the APIs to plot those things out.

21:50 What's the token economics of this?

21:54 Is it more efficient on tokens because it doesn't have to search around so much?

21:57 Or have you noticed a difference?

21:59 Yeah, that's a great question.

22:00 I think from the skill itself is a pretty slim markdown file that just teaches the agent

22:08 what this tool is and how to use this tool, which is run Python in the running kernel.

22:13 And then the agent is able to, maybe before the agent would read the entire notebook file

22:19 to figure out what you want to do.

22:20 but instead off of disk because it had to orient itself where you are inside the notebook.

22:26 Versus if I asked the agent, we're focusing on this cell right now inside the notebook.

22:31 The agent doesn't have to print off all the other cells into context.

22:34 It can just focus on that one cell or that one variable that we're talking about in the kernel.

22:38 So we haven't done anything formal to compare those things.

22:41 But essentially when you're able to extend the environment

22:45 with variables and values, then you give the agent the ability to offload context

22:50 into Python rather than bringing that as extra context that fills up your context buffer.

22:55 Yeah, my impression is that first estimate is it would be way more efficient, honestly.

23:00 Like a lot of times I'll see Claude Code or something

23:03 and go like, okay, I need to understand what this does.

23:06 Let me write a little Python script and execute it with a dash C or what,

23:10 you know, or I can just pass it as a string effectively.

23:13 And it's recreating all these things instead of just like print X

23:17 or just give me the value of X, right?

23:19 Yeah, exactly.

23:20 And actually you can think of each invocation of the tool

23:23 that we provide to the agent as essentially running Python-C,

23:27 except picking up wherever you left off inside of your notebook.

23:31 So it has the ability in that string that it passes to Python

23:35 to just reference variables that you currently have in memory.

23:38 And it doesn't have to perform something high up in that script

23:41 that might be costly to reload a data set or mangle it to get to some later state to print it out.

23:47 Instead, it can kind of pick up where you are currently in your notebook session, you

23:51 know, and tell me about my data frame.

23:52 And it can run a bunch of queries on the thing that you currently have in memory to tell

23:56 you about it.

23:56 Sure.

23:57 Okay.

23:57 Super interesting.

24:00 And let's talk just really quickly about this distributing as a skill.

24:05 I mean, there've been other attempts for notebooks that I've seen that are kind of like, we're

24:10 going to embed an LLM or at least an LLM integration in the notebook.

24:16 And it's interesting to see you shipping this as a skill plus a capability that's just in Maremo.

24:23 So on one hand, it's easy to think, well, that doesn't seem very useful.

24:27 But then again, there's always the what is now well-known SaaSpocalypse because Claude shipped 13 markdown files, which wiped $285 billion off of the stock market, right?

24:40 So there's something to these markdown files.

24:41 I really think it's quite powerful.

24:44 but how'd you come around to this distribution model?

24:48 Yeah, so Marimo, and I should be clear, Marimo today still has a chat integration

24:53 that you can bring your own LLM and actually drive an agent interface from there.

24:59 And even you can actually use the Marimo pair tools inside of that chat interface as well.

25:06 But increasingly we had users that were asking about, how do I use Claude Code with Marimo?

25:10 Or how do I use Codex with Marimo?

25:12 And what we started to realize is that These coding agents, we're building a tool that we'd like our users to spend a lot of time in.

25:20 But these coding agents outside of Marimo have a lot of access to things that aren't ever going to be inside of the Marimo user interface,

25:26 such as the different skills or MCPs or things that they've enabled for their main driver of doing development on their machine.

25:35 And we want to make sure that Marimo is a useful tool in that context as well.

25:38 And so increasingly, many of the folks on our team are using Claude Code for the actual development of Marimo.

25:44 and we started to feel this friction of when we wanted to work on a notebook

25:48 that we couldn't just start up the notebook and get it running from Claude

25:52 and then edit it.

25:53 Instead, it felt like we were jumping between tools.

25:56 At least initially, we were thinking how do we make Maremo notebooks

26:01 a useful tool for agents?

26:03 Then we started to look at best practices for doing that.

26:08 Simply a bare bones MCP was one approach that you could go with.

26:12 When we started to look at skills was I think around the fall slash December last year

26:18 when these models started to get quite good, the skills started to become a very useful vector

26:25 I think for packaging up reusable instructions for how to effectively use a particular command line tool or skill.

26:35 And so if you actually look at our skill today, it doesn't really tell you much about how the internals of Maremo works

26:41 or how that tool works.

26:43 And instead it just teaches the agent about where that tool exists

26:47 and how to use that tool.

26:49 But then if it wants to learn about how to invoke that tool

26:51 and the different capabilities that it has within that active kernel,

26:54 it actually uses the help command.

26:56 We instruct it to use the help command to print off the doc strings for itself

27:00 and then learn in that session how to effectively drive Marimo.

27:03 And so this actually has a sort of decoupling between our skill and Marimo's internals

27:08 because we don't actually publish anything in the skill that talks about the API that it will be using.

27:13 And instead we'd say, hey, go find that when you load the skill to figure out what capabilities

27:17 that you actually have inside the active kernel.

27:19 That's interesting.

27:20 That way, if you want to change it, you don't have to get people to update the skill, which

27:23 is always tricky.

27:24 Exactly.

27:25 This was the thing that we became very conscious of quite early is that updating Marimo and

27:30 updating the skill could get out of sync.

27:32 And we just wanted to make sure that our users didn't get into the state where they're having

27:37 a really poor experience using their agents because they upgraded Marimo and they hadn't

27:41 upgraded their skill. And so the skill isn't so prescriptive about exactly what the agent should

27:45 do, just more, hey, these are tools. And this is sort of the mental model of how you could drive

27:51 Marimo. And then should you want to drive Marimo, here's where you go find how to do that inside of

27:56 the active Marimo that you have in your session. Michael, I can't, I might have lost.

28:01 Sorry. So skills have been changing over time about how they're structured and they used to be

28:06 commands and then i don't know just the layout of these things is a little bit a little bit funky

28:12 um i mean i guess you could manage it from marimo like have it say like hey skill update available

28:18 push this button to reinstall it or something but it sounds pretty bare bones in terms of like just

28:24 go talk here and then you'll figure it out when you get there sounds sounds good yeah exactly and

28:29 you know some of these like agents have the ability like for instance in Claude Code and codex

28:35 If you have this marketplace.json file where you have your skill,

28:39 you can subscribe for auto-updates of that skill so you don't have to re-sync that file.

28:44 Or if you use one of these command-line tools for installing from GitHub,

28:47 you can install the latest.

28:50 If our users got out of sync, it's quite hard to figure out what version they have,

28:53 and maybe we'd need to do some runtime inspection.

28:55 So by really trying to have this decoupling of the skill from the capabilities that we have inside of Marimo,

29:01 we can ensure that there's sort of a baseline of user experience.

29:05 And then should folks want to upgrade to latest skill or upgrade Marimo,

29:09 hopefully both those things should, should, should improve that experience over time.

29:12 Yeah, for sure.

29:15 This portion of Talk Python is brought to you by us.

29:18 I want to give you a quick bit of news about the courses side of Talk Python.

29:23 Now, every single course at Talk Python training has full subtitles in German,

29:28 Spanish, and Portuguese.

29:30 That's all 283 hours completely translated, not just a couple of flagship courses.

29:36 Just click the CC button in your player, pick your language, and you can even resize and

29:42 reposition the captions so they don't cover the code.

29:44 If Deutsch, Espanol, or Portuguese is your first language, this one's for you.

29:50 Check it out at talkpython.fm.

29:52 Just click courses in the nav bar, log in, or create an account.

29:56 Even the free courses now come with subtitles in four different languages.

30:01 Let's walk through installing this and maybe a quick start story.

30:05 So first, installing it, how do we do?

30:08 Yeah, so whether or not you have a tool called...

30:11 So first of all, a skill is a folder of some files, and there's a file called skill.md.

30:17 This is like an official specification that you put somewhere on your file system for your agent to find.

30:23 And then there are a handful of tools that exist in open source

30:26 adding those files. And like I mentioned just a moment ago, being able to sort of upgrade those

30:30 files easily, either based off of Git syncing or by installing with one of these marketplaces. So

30:38 the way that we publish our skills, we have this repo, it's called marimoteam, marimopair.

30:42 The code that we publish there, we version over time. And you can either use, if you have the

30:48 npm package manager, you can use npxskillsadd marimoteam slash marimopair. That will start up

30:54 the command line tool to add those files to your file system. You can either install them locally

30:58 in a folder, globally on your system. If you don't have npm installed, you can actually use UV

31:04 and do uvx Dino A npm skills. And this will sort of shell out to Dino to actually install those for

31:11 you, but you can drive it through uv. If you have pod code. I've seen this so much. I'm like,

31:16 oh man, why are we stuck on NPM? I do have these things. So I'll put the uvx Dino dash A NPM

31:24 I feel like that could be a sweet new alias, just UVNPM.

31:33 I think that'd be nice.

31:34 I'm going to find a way to do that.

31:36 Yeah, definitely.

31:38 Short tangent, I actually got the Dino name for the Dino folks

31:42 so we could transfer over that package.

31:45 Being able to share packages between ecosystems without having to reinstall a new package manager

31:50 I think is really important because both the Python ecosystem and the npm ecosystem

31:55 are growing so much.

31:57 But it's a lot to ask of users to make sure that they have both these things installed,

32:00 especially if someone considers themselves a node person versus a Python person.

32:05 Let's just make sure that everyone has access.

32:06 It could be an offense to have to install npm.

32:09 I'm not just kidding.

32:11 So you're responsible for getting Dino as a PyPI package?

32:15 Yes, yeah.

32:16 I've collaborated a little bit with the Dino folks over the years.

32:19 I went through a very formal process with PyPy to request that name and then turn it over to them.

32:24 Oh, that's super cool.

32:25 So tell people real quick about Dino because they're like, well, what does that have to do with Node?

32:31 Yeah, so the creator of Dino was the same creator of Node.

32:35 And sort of the basis of Dino was, at least from the perspective of the Dino creators,

32:42 was to fix some of the things that had happened in the Node ecosystem.

32:45 And so Dino is a similar type of server-side JavaScript runtime,

32:50 but brings over a lot of functions a lot more similarly to the way that the browser has.

32:56 So it has a lot more fine-grained permissions baked into when you're trying to do something

33:00 like read the file system or read variables, you have to actually explicitly opt into those capabilities

33:07 while you're executing the script to allow that runtime to access those things.

33:13 Okay, yeah, very nice.

33:15 Now, do you have a preference here if I npx it or uvx it,

33:20 or is it better to do the marketplace type of thing?

33:24 Yeah, so this starts to come down to your agent of choice.

33:28 So the npx skills is a command line tool that's published.

33:32 Skills is a package that's on the npm registry that installs skills on your system

33:38 and sort of has a little CLI walkthrough where you can pick multiple agents,

33:43 like if you use Codex or use Claude Code or maybe OpenCode,

33:46 where it will install them to universal directories for those things.

33:51 So if you are someone that likes to play with a lot of different agent harnesses,

33:54 I'd probably recommend using NPX or uvx Dino.

33:59 Those are semantically equivalent.

34:02 They just eventually will trigger the same CLI.

34:05 It's just the package manager that's doing it is different.

34:08 Right, it's more npm versus plugin, exactly.

34:11 Yeah, and then the plugin is more, that's a specific install instruction to Claude Code.

34:17 And also I believe that Codex has something quite similar.

34:20 And there you can register what's called a marketplace for our Marimo team,

34:25 such that when we publish updates, when you boot up Claude Code one day,

34:30 maybe it'll ask you if you'd like to upgrade our plugin.

34:32 So that will sort of keep it in sync.

34:35 So if you are a Claude Code user, I think I'd generally recommend,

34:38 and mostly a Claude Code user, I'd generally recommend installing from the marketplace

34:42 versus if you're someone that's flipping around between a lot of tools,

34:45 the MPX skills does a good job and you can MPX skills upgrade

34:49 the Marimo pair skill as well.

34:50 Okay, that sounds really good.

34:53 I guess, yeah, the one is general, right?

34:55 And the one, the other, the plugin one is really Claude Code.

34:58 Although I suspect if you put it into Codex, it might just give you a little bit of snark

35:02 and install it.

35:04 Yeah, yeah, definitely.

35:05 I've accidentally invoked the skill with the four, I think in Codex,

35:09 it's the dollar sign to invoke skills and it's Claude, it's like this forward slash

35:13 and it figures it out.

35:15 Yeah, yeah, exactly.

35:17 You must be confused.

35:20 This doesn't even make sense.

35:21 What you meant to type was such and such.

35:24 Yeah, okay.

35:25 So is there like a getting started example or something like that on one of your pages

35:31 I can sort of point at?

35:33 Yeah, so if you have the skill installed, the best thing you can do is just spin up a Marimo session.

35:40 So you could even prompt, starting from your agent of choice,

35:43 say, start a Marimo notebook using the Marimo pair skill.

35:47 And then everything needed to actually start you pairing with Marimo

35:53 is baked into that skill.

35:55 So after you've run that uvx command, you should be able to spin up a notebook

36:00 and then connect to it with your agent and just start talking about some data

36:03 or talking about a notebook that you already have.

36:05 I guess, what are some of the use cases or whatever that you might go through with this.

36:11 How do you find it to be useful?

36:13 What are you all doing with it?

36:14 Yeah, I'd say Marimo pair is increasingly the main way that our users that prefer to author code with agents

36:20 are starting to create and share Marimo notebooks.

36:24 And so I think there are a lot of different use cases, but the way I like to think of it

36:28 is that it really ranges from a more hands-on versus hands-off approach to authoring notebooks.

36:33 So a more hands-on approach would be the workflow that I just described where you spin up a notebook session, maybe you have a data set and you want to

36:41 be hands-on looking at that data, making plots, more exploratory data analysis or more iterative

36:49 where you're hands-on working with the agent. But rather than writing the code, you're sort of

36:53 prompting the code with the agent and looking at the outputs and deciding where to go next.

36:56 So that's more on the head, the interactive or hands-on approach. And then we also have a set

37:01 of users that are driving Marimo, using Marimo pair and a more headless version as well, where

37:07 they might spin off many different Marimo pair sessions to work on a similar problem.

37:12 And at the end, they'll have these notebooks that are running

37:14 that then they can connect to and sort of check and see what the agent was working on inside of that session.

37:19 So essentially, when you want to start a task with data, you can open up your agent and spin up Marimo

37:24 and then start prompting towards working on that problem.

37:28 I see.

37:29 So maybe this headless story, like I have this data and I know I want some kind of description,

37:36 exploration summary of it. So, Hey, Claude, just create a notebook and just from scratch,

37:41 just do what you want to do to build it up. And then I'll go look at it. Right.

37:45 Yeah. And the other ones may be more like a coding, like a data coding sort of story. Yeah,

37:50 exactly. Yeah. And the, I think the nuance there of like why the more headless approach

37:55 like works quite well with Mareem L'Apair is that if, if you've had any experience with trying to

38:00 like one shot a program or one shot a notebook in the past, the agent doesn't really have a way of

38:05 verifying what it's doing or that like that whole notebook that it created works well or maybe just

38:10 at the end can like try to run the notebook and then we'll have to go back and fix cell by cell

38:14 versus marimo pair driving from marimo pair sort of forces the agent to build up the notebooks a

38:20 similar way that you would where you would actually go cell by cell so the first thing i have to do is

38:23 like load my data the second thing i have to do is you know inspect look at my nulls and if there

38:28 are errors in any of those steps the agent will correct them there rather than sort of generating

38:32 the whole notebook and then running it from scratch. And so we found that you get much

38:36 higher quality outputs when you are actually at the time of looking at the notebook, because

38:41 the process in which the agent had to go to create the notebook sort of guarantees that it has to run

38:46 because it adheres to the Marimo's constraints versus just generating the artifact and then

38:51 saying like, hey, I'm done and didn't really check the outputs at all. Right, exactly. It just could

38:56 be some well-formed but meaningless notebook, right?

38:59 Yeah.

39:00 What if I'm now we're, we're pushing up to the limits of my Marimo knowledge.

39:05 Cause I've not tried this, but what if I got a Marimo notebook and I say, open

39:09 up that project and VS Code, like for example, maybe I have a regular

39:14 programming project that's VS Code that has the Claude Code installed in it, like

39:20 the extension or whatever.

39:21 And inside there, part of it is a Marimo notebook.

39:25 Can I say open up that notebook in Marimo, but then also have Marimo pair,

39:31 but from within the VS Code, Claude Code,

39:34 or do I have got to go to the terminal?

39:36 What is this interoperability story?

39:38 Sure.

39:39 At Marimo, I'm responsible for our VS Code extension, which is integrated.

39:44 If you've ever tried to open up a Jupyter notebook inside of VS Code,

39:48 VS Code or Cursor have a built-in UI for notebooks.

39:52 We have a built-in UI for notebooks that reuses that sort of the VS Code native view,

39:58 except replacing with Maremo outputs.

40:00 And the latest thing I've been working on is getting the ability to have your agent inside of VS Code

40:06 drive those notebook outputs as well.

40:08 So that's something we should ship in probably the next week or so.

40:11 And there's, of course, I guess because of economics or lock-in or I don't know, whatever,

40:17 there's always, in all these editors, yes, even in Cursor,

40:21 There are like first class built-in ways to do agents.

40:26 Say in VS Code, there's like the chat thing on the right.

40:29 Those I think is probably what they intend you to do.

40:32 But then you can get the VS Code Claude or Codex extension,

40:37 which is a totally different UI, but still in VS Code.

40:40 Or you could go to the terminal and you could type Claude or Codex.

40:45 And that's a third sort of thing, which can sort of have links back in there.

40:50 Do some of these work and some of them don't?

40:51 Are they all the same?

40:53 What's the story?

40:54 Yeah, so if you're launching from the terminal or the integrated VS Code,

40:59 sorry, the Claude Code extension from VS Code today, that will likely start Marimo's command line tool

41:07 and then open up a web view inside of VS Code, which is like our Marimo editor.

41:11 If you use the chat, which is sort of the built-in agents panel inside of VS Code,

41:16 that would drive the usage of the more integrated view inside of VS Code.

41:22 But all three are possible, I guess, yeah?

41:25 Yeah, exactly.

41:26 You can start a Marimo pair session from any of those panels.

41:30 It's just a matter of what the visual that you're looking at is,

41:34 if that's going to be the native VS Code editor for the notebook versus a web view

41:42 of the Marimo notebook UI.

41:44 Yeah, and my sort of huff at this before was like, This is only here because Claude Code won't allow you to use your subscription in the other one.

41:56 It's got to be, you know, in certain circumstances, right?

41:59 Like, oh, if you use the official extension, you can use your subscription.

42:03 But if you use this other way, then you've like, say in Cursor, you use your Cursor credits, not your Claude Code subscription.

42:10 And then PyCharm, you've got the sort of duality as well, where if you use the AI chat section that uses your JetBrains AI credits, whereas like if you use the terminal, it's clawed and just it's kind of a mess, honestly.

42:24 Yeah, I think there's a lot of fragmentation in the ability to, and who owns that interface for where you're typing into that box and driving these tools.

42:34 And so from our perspective, we think there will likely be a continued amount of drift between these different tools.

42:43 And we don't necessarily want Marimo to be a tool that people are kind of deciding whether or not they're going to use our chat bar.

42:48 but we do think Marimo as an environment for working with your data should be accessible from

42:53 whatever tool that you choose. And so on our side, we just want to make sure that you're able to

42:58 connect to and drive a Marimo notebook from your agent harness and tool of choice.

43:03 I think in maybe some kind of idealistic, non-realistic world where all the frontier

43:12 foundation coding models, you could just tell it your subscription or tell it whatever,

43:16 and it's the same billing everywhere, it might be better to have some kind of built-in panel

43:22 into Marimo or little pop-ups or something.

43:25 But given all the weird restrictions and stuff, it seems like a really good plan

43:29 to just have Marimo good at talking to any agent through this way and however people want to run it,

43:36 they can just talk to it, right?

43:37 Yeah.

43:39 It's been challenging because we spend a lot of time on that UI and thinking about that UI

43:44 that we own inside of Marimo how this should work with these agents.

43:48 But the reality is that there's a lot of friction.

43:51 And if we would have tried to build around Claude Max like a year ago,

43:55 that would have been a lot of wasted effort because of the way that these platforms are changing.

43:59 So as these tools become increasingly sticky and folks get entrenched into their agents of choice,

44:05 I think from our perspective, making sure Marimo remains a useful tool

44:11 to any agent is really our priority.

44:13 And if there is some sort of...

44:15 yeah, future day where we can own that UI again, then I think we will certainly have a story there.

44:21 Yeah, I think I totally agree with you, but I want to share a little graph with you from the

44:26 Pragmatic Engineer newsletter. Yeah, I guess newsletter. So if you, there's this one that was

44:32 AI tooling for software engineers in 2026. So you scroll down till we see a graph. There we go.

44:38 If you look at what people are using, it's Claude Code.

44:44 And then quite a ways back, we get Google Copilot, which I think is really, I don't know, maybe I live in some kind of sheltered world.

44:52 But I feel like this is primarily used because companies have Microsoft 365 subscriptions and they've got 10,000 employees.

45:01 And they're like, you can use Copilot because it's approved.

45:04 I don't know that that's necessarily what people are seeking out as their top choice.

45:08 I don't know, I could be wrong.

45:09 Sorry if I got that wrong, Copilot folks.

45:11 But, and then maybe about half is Cursor and that's kind of its own world and then it goes Codex.

45:16 So like, I feel like if you're trying to, this is like Claude Code was way behind a year ago.

45:22 It's crazy.

45:23 So I feel like if you're building a tool, especially for developers that says,

45:28 let's pretend you don't want this.

45:30 Let us give you our version of something that's like it.

45:34 I just don't think that that's a road for success.

45:36 I think you're fighting against like, everyone's like, you know what, we're in Claude Code and it works really well. Why am I going to

45:42 go put that away and use your thing? As opposed to what you guys built, which is like, well, here's

45:46 how you use the top three of those things to talk to what you're already doing. I think that's a good

45:52 choice. Yeah, I think for us, it was the realization that the effectiveness of agents on a particular

45:58 task is a combination of like, I think an agent is by definition is like a model, the tools that you

46:03 equip that model with and then its environment or the loop that it runs in to perform that task.

46:09 And so its effectiveness is going to be limited by whatever tools you give that agent.

46:13 And so if we didn't make Marimo a useful tool for the agent, then if you give a data problem

46:18 to the agents, it's going to use the tools that it has at hand, which are reading and writing files

46:22 and running bash scripts. If you run that script a bunch of times or you ask the same data question

46:26 using those tools, you might get a folder with a lot of different scripts and things and maybe a

46:30 result. And so by giving agents, or really thinking of Marimo as a tool for agents,

46:36 then we don't have to think so much about the interface for the agent, but rather just how to

46:40 expose our environment to agents. And then when you ask for those data tasks, the thing that you

46:44 generate at the end is this reproducible Python program that is a Marimo notebook, but you can

46:49 drive that for many of these UIs of choice. And I look at these bars here, there's going to be

46:55 jumping back and forth between these, depending on what the providers dictate in terms of their

47:01 Who gets blocked by the US government, who doesn't?

47:04 Exactly.

47:05 For us at Marimo, as long as we can make sure that regardless of what agent you use,

47:09 you will have notebooks as a useful tool.

47:13 Then at the end of the day, you're still just generating Marimo notebooks.

47:16 Even if you turn off your agent, you have this reproducible artifact

47:19 that is useful for communicating your data results or something about what happened in that session while you're working with data.

47:26 That's our goal at Marimo, to make sure that whether you knew how to write Python code

47:30 or you don't know how to write Python code, you're able to produce this reproducible artifact

47:35 for your data analysis.

47:37 Okay.

47:38 You also talked about open code AI.

47:42 This is somewhat new to me.

47:44 What is this open code thing?

47:46 Yeah, so open code is similar.

47:48 I think Claude Code had the first form factor of being one of these terminal CLIs that you spin up.

47:54 but just with the Anthropic models.

47:58 And then OpenCode is a similar, like it feels very similar to using Claude Code,

48:03 but it allows you to configure a lot of different models that have the ability to configure API endpoints.

48:09 So for a while, I believe you can still configure all the different providers.

48:15 It's just like the type of subscription models that you can use with OpenCode change quite a bit,

48:20 similar to what you were just mentioning inside of VS Code.

48:24 Yeah, for example, it looks like you can use your Codex subscription, but not your Claude subscription.

48:31 Yeah, exactly.

48:32 So it should have a very similar form factor to when you type in Claude and you pop up that thing inside of your terminal.

48:39 If you type in OpenCode, you'll get a window.

48:41 You can start prompting.

48:43 You can also install skills for OpenCode as well, the same way that you install for any of these harnesses.

48:50 But we had some users that use OpenCode because of the open models.

48:53 We have some users that are using Claude Code.

48:55 We have some users that are using codex or VS Code.

48:58 And like I mentioned, we just want to make sure that anyone can drive a Marimo notebook.

49:02 So it must be tough to be supporting AI stuff in this space, given how much flux it's under.

49:08 Yeah, I think by inverting the problem in so far is that we are no longer like, you know,

49:14 by moving some of this ability to drive Marimo outside of the Marimo UI, we don't have to

49:19 keep up as much with all the fluctuation in the new models.

49:22 And instead, the thing that we can focus on is the skill and making sure that that interface for controlling Marimo is really good from any agent of choice.

49:31 And then as these different UIs compete for sort of where the users are going to be in terms of driving their agents, again, we can just sort of sit there with Marimo and just make sure Marimo is a really good tool for any of these agents.

49:46 Sure, sure, sure.

49:48 So having this, how does this change how people use notebooks?

49:53 I know how it's changed coding.

49:55 It's changed it quite a bit in some ways and not at all in others.

49:58 But how about for data?

49:59 That's a really good question.

50:00 So I mentioned earlier that part of the value of these environments

50:05 like a Marimo notebook or like a Jupyter or Excel is the statefulness of those environments.

50:10 And so it's really like there's a lot of, you know, when you're using an agent,

50:15 it's able to gather things and put it from your file system

50:19 to bring that into context or from the web to be able to, when you ask a prompt,

50:24 perform a task that hopefully fulfills that to some sufficient level.

50:28 And prior to having an integration like Marimo pair, that statefulness could be,

50:34 basically the values that are in memory could be extra context to helping the agent

50:40 answer some question, but you'd sort of have to babysit the model

50:43 or tell it something like, oh, I copied this output, here's the output.

50:46 And now when you say, what's in this data frame, it can look at those columns for you.

50:51 Or for example, if I'm doing something like EDA type of analysis

50:56 inside of Marimo, I can circle on a plot and make a selection.

50:59 And I can say, what did I just select here?

51:01 And the agent can go take that indice selection that I made,

51:05 compare it against the data frame, and come back to me with some answer.

51:07 So I think these types of questions that maybe felt tedious

51:11 to ask before, like, because you'd have to type out a lot of code to do that.

51:16 Now you can really either use the agent to help you write code or actually ask you questions

51:20 about the state inside that notebook.

51:22 And you're really extending the agent's, you know, environment with the intermediate values

51:27 that, you know, as a human might find interesting.

51:29 But now the agent can also use that as potential context.

51:32 One of the things I think is super useful.

51:35 A lot of times I feel like people maybe miss this and maybe, maybe more people than I realize

51:40 know about it, but in VS Code or PyCharm or cursor, I think cursor might be best as I'm not

51:46 entirely sure these days, but anyway, if I've got a file, maybe I've got hundreds of files in my

51:52 project, but a particular file I'm interested in, if I have that file open and I ask questions,

51:57 it's automatically included as context, just by virtue of having it be the last focused file.

52:03 But even better is you can highlight parts of a line or three lines or whatever and go,

52:08 what's wrong with this?

52:10 It's all you got to say.

52:11 And it goes, oh yeah, I see the function that you're talking about,

52:13 the part that you've highlighted, like boom, off it goes.

52:16 Is there some mechanism?

52:17 It sounds a little bit like there is, but is there a mechanism in Marimo

52:21 that it communicates back what's active, what you're working with?

52:25 Yeah, so we have, you know, as the agent is running things,

52:28 we can communicate, you know, what cells have changed

52:31 or like if there are values that have changed in the notebook

52:34 and then the agent can go and ask questions about those things that have changed.

52:38 We have some folks in our team that are working on creating these sort of,

52:41 like I think to what you're mentioning, imagine you highlight a line of code and you want to feed that back

52:46 as potential context of here's where I'm focusing.

52:49 Inside of a notebook, if you're using actually the integrated browser

52:53 inside a VS Code or cursor, you can actually click on a plot

52:57 and it'll take that screenshot and it'll add it as context

53:00 to what you're going to ask.

53:01 And so now you're having this interaction where it's not just the values

53:04 but also the outputs and the visual outputs that you can say,

53:07 hey, this is a little bit weird.

53:08 I see this, this, and this.

53:10 So we're definitely thinking that direction where, yeah, it's not just the line of code,

53:13 but the value of the code and the representation of the code

53:16 that could actually feed back to these multimodal models

53:18 and help you sort of come to better understanding quickly with your data.

53:22 Yeah, awesome.

53:23 I love it.

53:24 It's so nice because instead of trying to just like describe,

53:26 okay, and the third function called this, there's a part where there's an if,

53:31 you know, just like highlight and go this, right?

53:33 It's great.

53:34 Exactly.

53:35 There's a certain level of interactions or feeding back of...

53:38 I think when I started to realize that these agents could be very powerful

53:42 was when coding tasks started to feel a lot cheaper.

53:45 Like maybe these what-if ideas of something I wanted to try with software,

53:48 I could, rather than that taking up a whole weekend or several weeks to try out,

53:53 it's like maybe an afternoon I could try that out.

53:55 And I think the experience that we want to provide for our users inside of Marimo Notebooks

53:58 is that these kind of what-if questions with your data also feel very cheap.

54:03 So you say, what is that?

54:04 And now that like starts a conversation or starts a new part of your analysis that, you know, you maybe would have had to be very convinced to go down that route before.

54:11 And now you can just like start to ask those questions and hopefully get to insight more quickly.

54:15 I think another thing that that's really nice for is, you know, hat tip to the name here is like pair, like pair programming, right?

54:23 If you were actually paired programming, you could just highlight something on the screen and go, what do you think about this?

54:28 Right. Where's sort of the traditional, I don't know, Claude code just in the terminal.

54:33 You've got to describe it a lot, talk about the file, right?

54:36 Like you can't just have it sort of ambiently there.

54:40 And if you're sitting there working with these tools, these agentic tools all day,

54:45 especially if you're not doing a lot of programming with other people, like it's

54:47 primarily the, you're sort of coding partner, you know, your paired programmer or

54:52 whatever, the more you've kind of got to artificially step out and say, yeah,

54:56 over on this file at dah, dah, dah, dah, try to find the file.

54:59 And then you're talking about this, right?

55:01 It breaks this flow and this idea of this thing is here to help me.

55:06 It's like, I'm just sending stuff to this dumb machine

55:09 that can't really figure out what's going on.

55:11 So I really like it.

55:13 This concept you're talking about.

55:14 I had this experience where I was actually trying to help my dad

55:18 look at some data that he had in Excel.

55:20 Notoriously, that's very annoying to load an Excel file in Python

55:24 because you end up writing your own little parser to figure out the different subsets of the tables.

55:28 At the end of the day, what I really wanted were a couple data frames

55:31 plot inside of the notebook. And being able to just drag from my UI the Excel file over into

55:37 Marimo pair and saying, hey, can you just load these three tables inside the notebook and let

55:41 the agent chug away in the notebook at trying to figure out how to create those plots for me?

55:46 Maybe that would have taken me an hour to do on my hand from before. And it took a couple minutes

55:50 for the agent or maybe even a minute for the agent. And then I got to focus on the exciting

55:54 part was how to make these plots and communicate something with the data. So automating those pieces

55:58 that are very bespoke and kind of annoying of like, how do you get data formats into the notebook is

56:02 now something you can sort of, you know, task the agent on for a little bit. Right. I'm not a fan of

56:07 vibe coding really, but I do think this provides really interesting onboard, like on ramps for

56:12 people to get into notebooks and programming and so on. Cause maybe they can ask decent questions

56:19 about data, but they can't necessarily go, okay, I'm going to get the pie X amount, the XML,

56:24 XLS writer or whatever it is. Right. As you can tell, I don't remember exactly the name of it.

56:28 So there you go.

56:29 All right, that kind of thing.

56:30 And just like load this up and then let's talk about it.

56:32 Like I know what a data frame is, but I really need to know how to like select the third sheet in Excel.

56:38 Yes, exactly.

56:39 Do I need to know that API to like get my tasks done with these data inside the notebook?

56:43 And I think, you know, for in this context as well, because Marimo has this, you know,

56:49 this deterministic execution order, you can sort of collaborate on building, you know,

56:54 this like this reproducible like workflow of how you got to that notebook.

56:59 So you can, instead of vibe coding the whole thing, you can maybe allow someone to kind of vibe code

57:03 the first bit of how do we get the data into memory?

57:06 And then the things that really require attention about cleaning up the data and plotting the data

57:11 and running some modeling on that data, now you've sort of freed up your time

57:15 to focus on those bits as well.

57:17 Yeah, 100%.

57:18 It lets you focus on the parts that actually matter, not just silly file formats and stuff like that, right?

57:23 Yeah.

57:24 And we're lucky because Python's such a Swiss army knife to all that has such a rich ecosystem

57:28 of ingesting data and working with data that you can lean on that ecosystem

57:35 plus the agent inside of the notebook to get your data into a format that is useful.

57:39 But then that's the point that you step in and start to direct more about what direction

57:43 you want to take that analysis.

57:45 Totally.

57:45 So a couple of final questions to wrap up our conversation here.

57:49 Tips and tricks for people like, okay, you've got the skill, you've got Marimo.

57:54 Are there interesting things you've all discovered you can do

57:58 that maybe are non-obvious?

57:59 Tips and tricks.

58:00 Honestly, my recommendation would be to, if there is some data set that you have in mind,

58:05 like the example I mentioned with an Excel file, it's a very fun task to just drag in a data set and say,

58:11 please load this for me inside the notebook and let's start making some plots or something.

58:15 And I think very quickly you'll realize how quickly this runtime inspection

58:20 really shapes this user experience where I think I went from being very hands-on

58:25 with working in notebooks to being able to sit back a little bit more

58:29 and think cell-by-cell about what I want to do.

58:31 So I just encourage folks to try it out with their data and let us know what they run into.

58:37 Okay, yeah, that makes a lot of sense.

58:39 One thing that I've done before, just playing around with data,

58:42 is I've asked Claude, like, hey, here's the data, here's the scenario.

58:47 What are some interesting questions we should be asking about it?

58:51 here's what I think is interesting, but what am I missing?

58:55 Are there trends in the data that I don't see that maybe you can pull out

58:58 and just kind of have it just cruise around and just think about it a little bit?

59:01 And it was really good.

59:03 Yeah, and I think you can imagine extending that.

59:07 Typically when you're maybe asking those questions back and forth with Claude,

59:10 it's giving you some tables and numbers and distributions in the data.

59:14 But because when you're connected to a Marimo kernel, now you can ask for plots or different visual representations

59:20 that might be able to show those trends.

59:22 So if the agent is telling you that there is this difference,

59:25 you could say, hey, make a bar chart or a box plot for me to understand that information.

59:30 Because you do just have this much richer canvas for talking about your data

59:34 rather than just the ASCII output in your terminal.

59:37 Right, the first thing that I got was a bunch of data frames and heads

59:40 or stats or something like that.

59:43 And I'm like, this is great, but describe this in pictures.

59:47 And then I had a bunch of graphs.

59:48 And I'm like, okay, that was cool.

59:50 That was really cool.

59:51 Maybe people could try that, right?

59:53 Definitely.

59:53 All right, roadmap.

59:55 Where are things going?

59:56 Yeah, so as I mentioned, we are currently building a tighter integration

01:00:00 with our native editor inside of VS Code.

01:00:02 So essentially our direction with Marimo Pair is to try to think of all the places

01:00:06 in which folks are trying to drive agents that maybe we could have the ability

01:00:11 to spin up a Marimo notebook and allow folks to collaborate

01:00:13 on these reproducible artifacts.

01:00:17 So right now that looks a lot like more terminal oriented workflows.

01:00:21 We have some integration now inside the Marimo editor itself,

01:00:23 like I mentioned, where you can open up the chat

01:00:25 and start using Marimo pair.

01:00:27 We'll have a further integration into VS Code.

01:00:30 And I think down the line, we'll have eventually,

01:00:32 you know, if you're using Cloud Desktop or Codex Desktop,

01:00:35 that maybe you can start your little chat there.

01:00:37 And that could also drive a Marimo notebook as well.

01:00:39 I feel like that's an entirely missing piece of this whole agentic AI world,

01:00:44 like the Google Docs CoLab equivalent, right?

01:00:47 Like I've started up Claude Code or something like that.

01:00:50 And now, why don't you join my session?

01:00:52 We'll all talk to Claude and, you know, have it go.

01:00:55 I don't know, maybe someday.

01:00:56 Yeah, or maybe Maremo can serve.

01:00:58 Like, you know, we will have, we are currently working on some real-time collaboration features

01:01:03 inside of Maremo.

01:01:04 And maybe there's some way that, you know, multiple people have multiple agents that are talking to the same

01:01:08 Maremo kernel.

01:01:09 Each person with their agent buddy are all in there.

01:01:12 That seems totally reasonable as long as it's, you know, aware.

01:01:16 What about remote?

01:01:18 So I'm running Marimo, I'm not on my machine, but on some server or some cloud service or whatever,

01:01:24 but I've got my cloud local and I want to have those things work together.

01:01:28 Yeah, so the way that behind the scenes, like how the tool call works inside of Marimo,

01:01:34 it's a bash script that's called execute code.

01:01:37 That allows you to swap in a URL, whether that's on local host

01:01:40 or something remotely with some authentication.

01:01:42 And therefore you can connect your local cloud to some remote Marimo kernel as well.

01:01:47 And then you have a sandbox that's not running on your machine at all, but somewhere in the cloud.

01:01:51 But you're driving that from your local machine.

01:01:53 Some big machine with GPUs or whatever, that's a better place to run your code.

01:01:58 Yeah, exactly.

01:02:00 At Marimo, we have a cloud-hosted version of Marimo Notebooks that's called Molab

01:02:04 that we recently released on CoreWeave Infrastructure, where we have some GPUs for our community.

01:02:10 And you can actually today go inside that UI and click pair with an agent,

01:02:14 And you can copy a little cloud command and connect that to your Claude Code or your codex.

01:02:19 And then you can start pair programming locally with that remote sandbox in the cloud.

01:02:24 I love it. That's awesome.

01:02:25 All right, final call to action.

01:02:27 People are like, Marimo pair sounds cool.

01:02:29 What do you tell them? How do they get started?

01:02:30 Yeah, so I'd recommend going to marimo.io slash pair, grabbing the skill and spinning up a notebook of your own

01:02:38 and just trying to do tasks that you do with data.

01:02:41 Traditionally, maybe in a notebook or maybe if things haven't been going well inside that notebook.

01:02:46 We haven't put up the site yet.

01:02:47 That's right, it's coming soon.

01:02:49 I totally forgot you said that.

01:02:51 By the time this episode comes out, that will be there.

01:02:53 If you're watching the live stream, maybe give it a few days.

01:02:56 By the time this episode comes out, check out marimo.io.

01:03:00 Or go to our GitHub for marimo pair, install the skill, and show us what you build with Marimo,

01:03:06 regardless of if you're driving it with agents.

01:03:08 But we'd love to hear if you start using out agents where the skill falls short

01:03:13 and how we can really improve that user experience.

01:03:16 Cool.

01:03:16 Well, it seems like a really neat idea.

01:03:18 I think you're going to have a lot of success with it.

01:03:20 So thanks for coming on the show and sharing it with everyone.

01:03:23 Yeah, thanks so much for having me, Michael.

01:03:24 Yeah, you bet.

01:03:25 Bye.

01:03:27 This has been another episode of Talk Python To Me.

01:03:30 Thank you to our sponsors.

01:03:30 Be sure to check out what they're offering.

01:03:32 It really helps support the show.

01:03:34 This episode is brought to you by Sentry.

01:03:37 You know Sentry for the air monitoring, but they now have logs too.

01:03:40 And with Sentry, your logs become way more usable, interleaving into your error reports to enhance debugging and understanding.

01:03:48 Get started today at talkpython.fm/sentry.

01:03:51 If you or your team needs to learn Python, we have over 270 hours of beginner and advanced courses

01:03:57 on topics ranging from complete beginners to async code,

01:04:01 Flask, Django, HTML, and even LLMs.

01:04:04 Best of all, there's no subscription in sight.

01:04:07 Browse the catalog at talkpython.fm.

01:04:09 And if you're not already subscribed to the show on your favorite podcast player,

01:04:13 what are you waiting for?

01:04:15 Just search for Python in your podcast player.

01:04:16 We should be right at the top.

01:04:18 If you enjoy that geeky rap song, you can download the full track.

01:04:21 The link is actually in your podcast player show notes.

01:04:23 This is your host, Michael Kennedy.

01:04:25 Thank you so much for listening.

01:04:26 I really appreciate it.

01:04:28 I'll see you next time.

01:04:41 Thank you.