Michael Kennedy: Coding agents have gotten really good at one kind of work.
Michael Kennedy: You scope a feature, edit some files, run the test, ship it.
Michael Kennedy: It all happens on disk.
Michael Kennedy: But that is not how data work feels.
Michael Kennedy: You load something, you look at it, you run a cell, you watch how it responds,
Michael Kennedy: you decide the next move from whatever is sitting in memory.
Michael Kennedy: And until now, your agent couldn't see any of that.
Michael Kennedy: They only saw files, never the live state.
Michael Kennedy: On this episode, that wall comes down.
Michael Kennedy: Marimo pair drops a coding agent right inside a running notebook with full access to every variable Python is holding in memory.
Michael Kennedy: The notebook becomes a shared canvas.
Michael Kennedy: You point, it runs the code.
Michael Kennedy: You tell it to zoom in on a graphic and the chart just updates.
Michael Kennedy: No MCP tools to wire up, no schema to describe, just Python and an agent that can finally see what you see.
Michael Kennedy: Trevor Manz from Marimo is back to walk us through it.
Michael Kennedy: This is Talk Python To Me, episode 555, recorded June 30th, 2026.
Michael Kennedy: Welcome to Talk Python To Me, the number one Python podcast for developers and data scientists.
Michael Kennedy: This is your host, Michael Kennedy.
Michael Kennedy: I'm a PSF fellow who's been coding for over 25 years.
Michael Kennedy: Let's connect on social media.
Michael Kennedy: You'll find me and Talk Python on Mastodon, BlueSky, and X.
Michael Kennedy: The social links are all in your show notes.
Michael Kennedy: You can find over 10 years of past episodes at talkpython.fm.
Michael Kennedy: And if you want to be part of the show, you can join our recording live streams.
Michael Kennedy: That's right.
Michael Kennedy: We live stream the raw uncut version of each episode on YouTube.
Michael Kennedy: Just visit talkpython.fm/youtube to see the schedule of upcoming events.
Michael Kennedy: Be sure to subscribe there and press the bell so you'll get notified anytime we're recording.
Michael Kennedy: This episode is brought to you by Sentry.
Michael Kennedy: You know Sentry for the error monitoring, but they now have logs too.
Michael Kennedy: And with Sentry, your logs become way more usable,
Michael Kennedy: interleaving into your error reports to enhance debugging and understanding.
Michael Kennedy: Get started today at talkpython.fm/sentry.
Michael Kennedy: Trevor, welcome back to Talk Python.
Michael Kennedy: Great to have you back.
Michael Kennedy: Yeah, thanks for having me again.
Michael Kennedy: We'll probably talk about notebooks, data science, maybe a little bit of AI in the mix.
Trevor Manz: Yeah, definitely. We've been doing a lot at Marimo and thinking about how agents can play nice with notebooks.
Michael Kennedy: 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.
Michael Kennedy: Now, before we get into that, it's been a year since you've been on the show to talk about AnyWidget.
Michael Kennedy: Just give us a quick introduction for folks who maybe didn't listen to that episode.
Trevor Manz: Yeah, AnyWidget is both a specification and a toolkit for making interactive UI elements
Trevor Manz: that deeply integrate into your interactive programming environments,
Trevor Manz: and specifically Python environments.
Trevor Manz: It has deep integration into Marimo, which is the company that I work at now,
Trevor Manz: where we build a new kind of reactive Python notebook.
Michael Kennedy: I'm a fan of Marimo. I don't do that much stuff in notebooks,
Michael Kennedy: but if I did, I would be using Marimo most of the time.
Michael Kennedy: It's kind of like that Dos Equis.
Michael Kennedy: Yeah, yeah.
Trevor Manz: I like to, depending on the ilk of user that we have,
Trevor Manz: I like to make the joke that there are often
Trevor Manz: a certain group of folks that have plenty of notebook friends
Trevor Manz: but don't really use notebooks themselves.
Trevor Manz: And I'd like to at least pitch why I think Marimo
Trevor Manz: scratches the itch of many more software developers
Trevor Manz: and represents more traditional software
Trevor Manz: than traditional computational notebooks.
Michael Kennedy: I think it also kind of is special for people
Michael Kennedy: We were more on the software development side because it's a little more Python focused instead of special tool focused in that.
Michael Kennedy: We'll talk about Marimo in a second.
Michael Kennedy: But like, for example, instead of having IPY and B files, it has just Python files.
Trevor Manz: Yeah, we are hyper focused on Python.
Trevor Manz: 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.
Trevor Manz: It's all oriented around the Python ecosystem.
Michael Kennedy: Yeah, that's probably going to pay off a little bit when we talk about this project here.
Trevor Manz: Yeah, definitely.
Trevor Manz: Definitely.
Michael Kennedy: All right, well, actually, let's do a quick refresher on just what Marimo is.
Michael Kennedy: Am I saying that right?
Michael Kennedy: Marimo?
Michael Kennedy: Sorry, I should be saying Marimo, right?
Trevor Manz: Yep, it's Marimo.
Trevor Manz: Yep.
Michael Kennedy: Okay.
Michael Kennedy: Give us a quick refresher for people who don't know.
Michael Kennedy: You know, it's sort of in the realm of JupyterLab, but also different.
Trevor Manz: Yeah.
Trevor Manz: Marimo is spiritually a computational notebook, much similar to something like Jupyter or Google
Trevor Manz: Colab, if folks have used that before.
Trevor Manz: But as we just mentioned earlier in the show, we're hyper-focused on the Python ecosystem.
Trevor Manz: And we are also a special kind of notebook in that we are a reactive Python notebook.
Trevor Manz: So what that means is that the order in which Marimo understands your notebook is not in the
Trevor Manz: order that you wrote the cells, but the actual data flow between the cells.
Trevor Manz: And so we understand the relationships between your cells based off of the variables they
Trevor Manz: declare and where those variables are used.
Trevor Manz: 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.
Trevor Manz: 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.
Michael Kennedy: It sounds like a minor feature, this reactive bit, but it's not so minor.
Michael Kennedy: 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.
Michael Kennedy: and maybe go back three cells, edit something, rerun that cell,
Michael Kennedy: go down back to where they were and continue.
Michael Kennedy: Like, why is this?
Michael Kennedy: It doesn't seem to do anything.
Michael Kennedy: Or this is not what I expected or whatever.
Michael Kennedy: And then you realize, oh, because I didn't run the two cells
Michael Kennedy: or the one cell in the middle that actually used that value,
Michael Kennedy: which then flowed on to the next, right?
Michael Kennedy: And basically what you're saying with this Reactive Notebooks
Michael Kennedy: is unless you overwrite it or something,
Michael Kennedy: that can't happen with Marimo.
Trevor Manz: Yeah, it's essentially when you're working
Trevor Manz: something like a Jupyter notebook,
Trevor Manz: you, the user, have to do a form of bookkeeping
Trevor Manz: to make sure that whatever state exists in the kernel
Trevor Manz: is representative of whatever cells you have on the screen.
Trevor Manz: And discipline doesn't really scale necessarily,
Trevor Manz: or it becomes hard to do that bookkeeping yourself.
Michael Kennedy: Come on, I don't buy it because look,
Michael Kennedy: when you go into Jupyter, it says like 27, 34, 57, 58, and then 90.
Michael Kennedy: And if you see one of those,
Michael Kennedy: if you're not doing your bubble sorting,
Michael Kennedy: that's out of order. You know you've got to go back and run it. I mean, we all keep track of this.
Trevor Manz: Yeah, but essentially the moment that you get to some sort of complex notebook and state,
Trevor Manz: that becomes a lot of cognitive overhead that you as the user sort of have to keep in mind in order
Trevor Manz: to ensure that what you're doing is representative, such that when you hand off your notebook to
Trevor Manz: someone else, they're able to confidently reproduce that execution that you had in front of you and get
Michael Kennedy: back to that state. And so with Maremo, we offload that.
Michael Kennedy: It's just about that, right?
Michael Kennedy: Like that's obviously a problem.
Trevor Manz: Yeah.
Trevor Manz: And so at Marimo, you essentially offload that bookkeeping to a system,
Trevor Manz: which we do this dependency tracking of your variables
Trevor Manz: and where they're declared and where they're used.
Trevor Manz: And essentially we can provide guarantees that if you try to do something like
Trevor Manz: rerun a cell, we will rerun all descendant cells of that cell.
Trevor Manz: Or if you try to redeclare a variable, we'll tell you,
Trevor Manz: hey, you already declared this variable and eliminate this problem of hidden state.
Trevor Manz: such that when you do end up working on a team
Trevor Manz: with more than one individual
Trevor Manz: and you want to hand off that artifact to someone,
Trevor Manz: they can confidently run the notebook
Trevor Manz: and reproduce the execution results
Trevor Manz: that you were looking at
Trevor Manz: when you ran that notebook earlier.
Michael Kennedy: Yeah, it pretty much guarantees ordering.
Michael Kennedy: Yep.
Michael Kennedy: Okay.
Michael Kennedy: Also, it's got a really nice modern UI feel, I think.
Michael Kennedy: It looks good.
Michael Kennedy: It feels fresh.
Michael Kennedy: And I don't know, for some people,
Michael Kennedy: maybe that doesn't matter.
Michael Kennedy: But to me, I'm working on stuff.
Michael Kennedy: I just feel better if it's a nice UI and it looks polished instead of old school.
Trevor Manz: Yeah, and because we are hyper-focused on the Python ecosystem,
Trevor Manz: we've been able to think about common data structures and objects that are in the Python ecosystem
Trevor Manz: and then really have polished user experiences for inspecting and understanding those objects.
Trevor Manz: So inside of a Marimo notebook, if you load a data frame, whether that's a Polars data frame
Trevor Manz: or a Pandas data frame or an IBIS table or anything that implements this data frame protocol,
Trevor Manz: which is a standard in the Python ecosystem,
Trevor Manz: we can represent and render
Trevor Manz: in a really nice interactive table.
Trevor Manz: And so we're able to do that
Trevor Manz: because we're tailored around this Python ecosystem
Trevor Manz: and we're able to polish both the user experience
Trevor Manz: on the front end side
Trevor Manz: as well as all the way down to the kernel
Trevor Manz: in terms of being able to share
Trevor Manz: these reproducible notebook documents.
Michael Kennedy: Okay, yeah, I love it.
Michael Kennedy: All right, so that's Marimo.
Michael Kennedy: And what we're talking about today
Michael Kennedy: is not exactly Marimo,
Michael Kennedy: but more AI plus notebooks in a particular tool, agent skill.
Michael Kennedy: I don't know.
Michael Kennedy: We're going to get into that, what it is.
Michael Kennedy: But before we do, let's just talk about how do people,
Michael Kennedy: like what do people do with, say, either Marima or Jupyter or JupyterLab today
Michael Kennedy: without a tool like Marima pair?
Trevor Manz: Yeah, I'd say that the software as I've known it over the past year
Trevor Manz: has changed quite a bit for traditional software development.
Trevor Manz: And as we started working more and more on Marimo,
Trevor Manz: we were using agents to perform more of our traditional software development.
Trevor Manz: And many of our users were asking,
Trevor Manz: what's the best way to use Marimo with agents?
Trevor Manz: Because they've been using Marimo.
Trevor Manz: And I think that many different,
Trevor Manz: if you'd ever tried out of the box to use one of these coding agents with notebooks,
Trevor Manz: whether it be Marimo or JupyterLab or Jupyter or Google Colab,
Trevor Manz: there kind of felt like this difference or like awkwardness in that user experience in terms of
Trevor Manz: being able to drive that interactive environment in a way that I think was very sort of unsettling
Trevor Manz: or unfulfilling compared to traditional software development because you're able to sort of like
Trevor Manz: put off your agent on these long-lived software tasks and then come back and have it run the test
Trevor Manz: and let it get in these type loops to be able to autocorrect and do this sort of like traditional
Trevor Manz: programming and software development.
Trevor Manz: But when you tried to apply it to a data problem,
Trevor Manz: things would happen where you edit the file
Trevor Manz: and then you could get to some inconsistent state
Trevor Manz: inside the notebook,
Trevor Manz: or the agent couldn't actually see the actions
Trevor Manz: that it performed inside that notebook.
Trevor Manz: And it wasn't really able to get inside those tight loops.
Trevor Manz: And so we really started thinking from the bottom up,
Trevor Manz: how can we open up Marimo in such a way
Trevor Manz: that it's actually useful to an agent
Trevor Manz: rather than just this data source that it can query
Trevor Manz: and really try to extend that agent's working environment with notebooks the same way that,
Trevor Manz: you know, humans have used notebooks for working on data tasks.
Michael Kennedy: I think notebooks are particularly tricky for AI to work with because many people know,
Michael Kennedy: but probably not everyone.
Michael Kennedy: When you look at a Jupyter notebook, the IPY in B file, you've got your cell definition
Michael Kennedy: with code or markdown or whatever's in there.
Michael Kennedy: But also, and this is the part that makes it tricky part of the part, is that all the output.
Michael Kennedy: 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?
Michael Kennedy: And so as a Claude Code or a codex or whatever that's going to go through and try to understand it,
Michael Kennedy: it's got to skim through all of that output, determine most of it is irrelevant to me.
Michael Kennedy: Some of it is relevant.
Michael Kennedy: Maybe it was run in the wrong order.
Michael Kennedy: So if it does try to look at the output, it's actually, right, there's no enforcement of an order.
Michael Kennedy: And so if it's run in the wrong order, the output might be present and they might want to use it,
Michael Kennedy: but it's actually wrong because it was run, it's stale from what's actually in there.
Michael Kennedy: There's a lot of issues, right, to just work directly on the file format.
Trevor Manz: Yeah, I think, you know, as we started thinking about this problem, I think that we, you know,
Trevor Manz: even ourselves at Marimo started to realize that for notebooks, these file formats are more the
Trevor Manz: artifact of the work rather than the source necessarily of the code. And really, it's the
Trevor Manz: editor combined with the state, which is how you are authoring these notebooks in this live,
Trevor Manz: interactive environment. And that by just allowing agents to use their tools out of the box and edit
Trevor Manz: those artifacts on disk, they're missing a lot of the context in which those files are actually
Trevor Manz: authored. And they're also, in what you just mentioned, they are polluted with additional
Trevor Manz: context that's not necessarily useful to like performing a coding task on behalf of the user.
Michael Kennedy: Yeah, it's like, hey, Claude, work on this. And by the way, here's 10,000 lines of stuff that may
Michael Kennedy: either help you or harm you depending on stuff you can't determine really.
Trevor Manz: Yeah, exactly. So I think we started to think about this as more, you know, humans, like,
Trevor Manz: you know, out of the box, these coding agents are equipped with sort of like the ability to read
Trevor Manz: and write files and run bash scripts. And those tools really fit like the tasks of traditional
Trevor Manz: software development because that type of like the way that our command line tools and work that we
Trevor Manz: do for traditional software development work or that the file system is really the source of truth
Trevor Manz: and then you like make changes to those files and then you run sort of these like stateless commands
Trevor Manz: that like run your tests or basically take those changes and apply them and see if like what effect
Trevor Manz: that those have had and humans you know for data tasks have have sort of gone beyond the tools of
Trevor Manz: reading and writing and editing files and running batch scripts and instead we use these really like
Trevor Manz: interactive repls or sort of live programming environments for working with data because they
Trevor Manz: give us this ability to like iterate on intermediate results and values. So it's not like you run a
Trevor Manz: script, maybe you made an error, you have to run that script again from scratch. Instead, we can
Trevor Manz: like load a data set into memory and then sort of inspect those values and sort of iterate on them
Trevor Manz: in memory. And so like the usefulness of those sort of interactive environments like Excel or
Trevor Manz: Jupyter or Marimo or even something like RStudio is that they're stateful. And one problem is that
Trevor Manz: these agents weren't really good at accessing those stateful environments. And so that's exactly what
Trevor Manz: made it hard for us to open up those environments to agents. And I think there are many different
Trevor Manz: approaches that folks have taken. And even we took originally to try to make Marimo a useful tool.
Trevor Manz: And it took us a little while to figure out what were the ergonomics that work well for agents.
Michael Kennedy: Sure. So what you're saying is basically, instead of running on the file system,
Michael Kennedy: like the coding agents do now for, say, my code, I guess,
Michael Kennedy: what instead they need is they need to run in the kernel,
Michael Kennedy: kind of looking at the state of things in the kernel as it's working
Michael Kennedy: more than, say, regular programming code.
Trevor Manz: Exactly. Yeah. Because, you know, when we, as humans have adopted these tools,
Trevor Manz: the reason we adopt them is because it's not just the code,
Trevor Manz: it's the values and the in-memory representations of those data
Trevor Manz: So it's not just that I have this data frame on disk or this file on disk that has my data,
Trevor Manz: it's that I want to look at the table and I want to see what those values are. And that may determine
Trevor Manz: the next step that I'm going to take with that data of what plots I'm going to do or what validations
Trevor Manz: I'm going to run on these data. And so really we had to sort of invert that thinking and think more
Trevor Manz: about how do we extend these agents with a useful tool, which is a notebook for doing this sort of
Trevor Manz: data work and iterating on those intermediate values.
Michael Kennedy: This portion of Talk Python To Me is brought to you by Sentry.
Michael Kennedy: You know Sentry for their great error monitoring, but let's talk about logs.
Michael Kennedy: Logs are messy.
Michael Kennedy: Trying to grep through them and line them up with traces and dashboards just to understand
Michael Kennedy: one issue isn't easy.
Michael Kennedy: Did you know that Sentry has logs too?
Michael Kennedy: And your logs just became way more usable.
Michael Kennedy: Sentry's logs are trace connected and structured, so you can follow the request flow and filter
Michael Kennedy: by what matters. And because Sentry surfaces the context right where you're debugging, the trace,
Michael Kennedy: relevant logs, the error, and even the session replay all land in one timeline. No timestamp
Michael Kennedy: matching, no tool hopping. From front end to mobile to back end, whatever you're debugging,
Michael Kennedy: Sentry gives you the context you need so you can fix the problem and move on. More than 4.5 million
Michael Kennedy: developers use Sentry, including teams at Anthropic and Disney+. Get started with Sentry
Michael Kennedy: logs and error monitoring today at talkpython.fm/sentry. Be sure to use our code talkpython26.
Michael Kennedy: The link is in your podcast player show notes. Thank you to Sentry for supporting the show.
Michael Kennedy: Maybe good time to introduce Marimo pair. What is this? Yeah, so Marimo pair is an agent skill
Trevor Manz: that drops an agent inside of an active Marimo kernel. And it allows basically it's a single tool
Trevor Manz: that allows the agent to run Python code inside of that kernel
Trevor Manz: to inspect and perform any sort of understanding
Trevor Manz: what sort of intermediate values you have
Trevor Manz: inside of your kernel environment,
Trevor Manz: but then also drive the authorship of the notebook itself
Trevor Manz: and run and execute cells.
Trevor Manz: So basically it allows the agent to do anything
Trevor Manz: you could do in a Marimo notebook
Trevor Manz: and extend your analysis with an agent
Trevor Manz: by giving the agent the ability to drive the exploration
Trevor Manz: of a Marimo notebook.
Michael Kennedy: Interesting.
Michael Kennedy: Okay, so how does it get inside the notebook?
Michael Kennedy: You know what I mean?
Michael Kennedy: Do you have to change your code or something like that?
Michael Kennedy: Do you have to include something?
Trevor Manz: Yeah, so the setup is essentially an agent skill
Trevor Manz: that you can install either from,
Trevor Manz: if you're using something like Claude Code,
Trevor Manz: you can install it from the Cloud Marketplace.
Trevor Manz: You can install from Codex from a Marketplace as well.
Trevor Manz: Or you can use an NPX command to install a skill from GitHub.
Trevor Manz: And that skill teaches the agent how to use a single tool,
Trevor Manz: which is essentially just run Python.
Trevor Manz: And that single tool call allows the agent to run any kind of Python it wants to in the running Marimo kernel.
Trevor Manz: So inside that kernel environment, it can do things like list variables that are in the notebook.
Trevor Manz: It can inspect the cells of the notebook and look at the outputs of the notebook.
Trevor Manz: 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.
Trevor Manz: 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.
Trevor Manz: and is able to get back into these agentic loops for doing these tasks.
Trevor Manz: But using Marimo as sort of the workspace for performing your data tasks
Trevor Manz: rather than editing the file system.
Michael Kennedy: Yeah, okay, that makes sense.
Michael Kennedy: And I guess there's some kind of API or something that the agent can use to talk to the running notebook.
Trevor Manz: Yeah, so we sort of hide an API within Marimo that's called code mode.
Trevor Manz: And what code mode is essentially is this semi-private API
Trevor Manz: that's just meant for agents that are running Python inside of that kernel.
Trevor Manz: And with that API, the agent can grab the current notebook state
Trevor Manz: and talk to Marimo directly.
Trevor Manz: So it can do things like toast notifications in the UI that say,
Trevor Manz: hey, I'm connected to your notebook session.
Trevor Manz: It can do things like I mentioned before,
Trevor Manz: like list out variables or inspect what cells declare different variables.
Trevor Manz: But then also it has these sort of mutation APIs
Trevor Manz: where I want to say create cell, edit cell, run cell.
Trevor Manz: And because it's all Python and not individual something like MCP tools,
Trevor Manz: the agent has the ability to write Python code
Trevor Manz: that really does complex composition of those primitives as well.
Trevor Manz: So it can create multiple cells at the same time
Trevor Manz: just by calling create cell five times inside of some sort of loop.
Trevor Manz: Because we're giving it Python as the tool
Trevor Manz: rather than sort of a JSON API.
Michael Kennedy: I'll say, for me, it kind of boggles the mind
Michael Kennedy: how much Claude Code just relies on grep to understand projects.
Michael Kennedy: And it seems super inefficient to me.
Michael Kennedy: I mean, Claude Code was created in two weeks, something like that.
Michael Kennedy: It feels very much JavaScript-y in that regard.
Michael Kennedy: Like, look what you built.
Michael Kennedy: Also, look at the missing pieces a little bit.
Michael Kennedy: And as impressive as it is, it seems like if it could ask the question,
Michael Kennedy: where is this symbol used throughout my project?
Michael Kennedy: What is the value of this variable?
Michael Kennedy: Things like that.
Michael Kennedy: What is the type of it?
Michael Kennedy: Without reading and jumping around 100,000, a million lines of code all the time, it would
Michael Kennedy: be way more efficient.
Michael Kennedy: And it sounds a little bit like that's how it interacts with your notebook through Marimo
Michael Kennedy: Pair.
Trevor Manz: Yeah.
Trevor Manz: So within that code execution point where it can run Python code, the agent has the ability
Trevor Manz: to look at the source of those cells, but then also can look at the in-memory values
Trevor Manz: of those cells as well.
Trevor Manz: And therefore, it can, like you were just saying, it can look at the type, it can look at the
Trevor Manz: values.
Trevor Manz: and this type of runtime inspection of values
Trevor Manz: really does change model behavior
Trevor Manz: in terms of, like I mentioned before,
Trevor Manz: allowing them to get into these loops
Trevor Manz: and efficiently get to some sort of problem,
Trevor Manz: resolution to some task or problem inside the notebook
Trevor Manz: because it's able to course correct
Trevor Manz: and ask a lot richer information about your values.
Trevor Manz: Because if you're looking at a source code on disk,
Trevor Manz: maybe for a file that loads a data frame,
Trevor Manz: you just have a single line that says,
Trevor Manz: you know, load, Polars read CSV or pandas read CSV.
Trevor Manz: And then the agent would actually have to go look at that CSV to understand what's in that CSV
Trevor Manz: and combining that with the source code.
Trevor Manz: But if you pair that with a live REPL like we have inside of Marimo,
Trevor Manz: the agent could just say, you know, the agent now has a data frame that it can look at.
Trevor Manz: And that's a much richer representation of that static file on disk.
Trevor Manz: And then the agent can ask about the schema.
Trevor Manz: It could ask about, yeah, the different columns, the data types of the columns.
Trevor Manz: It could figure out the number of rows.
Trevor Manz: 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.
Trevor Manz: 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.
Michael Kennedy: What's the token economics of this?
Michael Kennedy: Is it more efficient on tokens because it doesn't have to search around so much?
Michael Kennedy: Or have you noticed a difference?
Trevor Manz: Yeah, that's a great question.
Trevor Manz: I think from the skill itself is a pretty slim markdown file that just teaches the agent
Trevor Manz: what this tool is and how to use this tool, which is run Python in the running kernel.
Trevor Manz: And then the agent is able to, maybe before the agent would read the entire notebook file
Trevor Manz: to figure out what you want to do.
Trevor Manz: but instead off of disk because it had to orient itself
Trevor Manz: where you are inside the notebook.
Trevor Manz: Versus if I asked the agent,
Trevor Manz: we're focusing on this cell right now inside the notebook.
Trevor Manz: The agent doesn't have to print off all the other cells into context.
Trevor Manz: It can just focus on that one cell or that one variable
Trevor Manz: that we're talking about in the kernel.
Trevor Manz: So we haven't done anything formal to compare those things.
Trevor Manz: But essentially when you're able to extend the environment
Trevor Manz: with variables and values,
Trevor Manz: then you give the agent the ability to offload context
Trevor Manz: into Python rather than bringing that as extra context
Trevor Manz: that fills up your context buffer.
Michael Kennedy: Yeah, my impression is that first estimate
Michael Kennedy: is it would be way more efficient, honestly.
Michael Kennedy: Like a lot of times I'll see Claude Code or something
Michael Kennedy: and go like, okay, I need to understand what this does.
Michael Kennedy: Let me write a little Python script
Michael Kennedy: and execute it with a dash C or what,
Michael Kennedy: you know, or I can just pass it as a string effectively.
Michael Kennedy: And it's recreating all these things
Michael Kennedy: instead of just like print X
Michael Kennedy: or just give me the value of X, right?
Trevor Manz: Yeah, exactly.
Trevor Manz: And actually you can think of each invocation of the tool
Trevor Manz: that we provide to the agent
Trevor Manz: as essentially running Python-C,
Trevor Manz: except picking up wherever you left off inside of your notebook.
Trevor Manz: So it has the ability in that string that it passes to Python
Trevor Manz: to just reference variables that you currently have in memory.
Trevor Manz: And it doesn't have to perform something high up in that script
Trevor Manz: that might be costly to reload a data set or mangle it
Trevor Manz: to get to some later state to print it out.
Trevor Manz: Instead, it can kind of pick up where you are currently in your notebook session, you
Trevor Manz: know, and tell me about my data frame.
Trevor Manz: And it can run a bunch of queries on the thing that you currently have in memory to tell
Trevor Manz: you about it.
Michael Kennedy: Sure.
Michael Kennedy: Okay.
Michael Kennedy: Super interesting.
Michael Kennedy: And let's talk just really quickly about this distributing as a skill.
Michael Kennedy: I mean, there've been other attempts for notebooks that I've seen that are kind of like, we're
Michael Kennedy: going to embed an LLM or at least an LLM integration in the notebook.
Michael Kennedy: And it's interesting to see you shipping this as a skill plus a capability that's just in Maremo.
Michael Kennedy: So on one hand, it's easy to think, well, that doesn't seem very useful.
Michael Kennedy: 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?
Michael Kennedy: So there's something to these markdown files.
Michael Kennedy: I really think it's quite powerful.
Michael Kennedy: but how'd you come around to this distribution model?
Trevor Manz: Yeah, so Marimo, and I should be clear,
Trevor Manz: Marimo today still has a chat integration
Trevor Manz: that you can bring your own LLM
Trevor Manz: and actually drive an agent interface from there.
Trevor Manz: And even you can actually use the Marimo pair tools
Trevor Manz: inside of that chat interface as well.
Trevor Manz: But increasingly we had users that were asking about,
Trevor Manz: how do I use Claude Code with Marimo?
Trevor Manz: Or how do I use Codex with Marimo?
Trevor Manz: And what we started to realize is that
Trevor Manz: These coding agents, we're building a tool that we'd like our users to spend a lot of time in.
Trevor Manz: 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,
Trevor Manz: such as the different skills or MCPs or things that they've enabled for their main driver of doing development on their machine.
Trevor Manz: And we want to make sure that Marimo is a useful tool in that context as well.
Trevor Manz: And so increasingly, many of the folks on our team are using Claude Code for the actual development of Marimo.
Trevor Manz: and we started to feel this friction
Trevor Manz: of when we wanted to work on a notebook
Trevor Manz: that we couldn't just start up the notebook
Trevor Manz: and get it running from Claude
Trevor Manz: and then edit it.
Trevor Manz: Instead, it felt like we were jumping between tools.
Trevor Manz: At least initially, we were thinking
Trevor Manz: how do we make Maremo notebooks
Trevor Manz: a useful tool for agents?
Trevor Manz: Then we started to look at best practices
Trevor Manz: for doing that.
Trevor Manz: Simply a bare bones MCP
Trevor Manz: was one approach that you could go with.
Trevor Manz: When we started to look at skills
Trevor Manz: was I think around the fall slash December last year
Trevor Manz: when these models started to get quite good,
Trevor Manz: the skills started to become a very useful vector
Trevor Manz: I think for packaging up reusable instructions
Trevor Manz: for how to effectively use a particular command line tool or skill.
Trevor Manz: And so if you actually look at our skill today,
Trevor Manz: it doesn't really tell you much about how the internals of Maremo works
Trevor Manz: or how that tool works.
Trevor Manz: And instead it just teaches the agent
Trevor Manz: about where that tool exists
Trevor Manz: and how to use that tool.
Trevor Manz: But then if it wants to learn
Trevor Manz: about how to invoke that tool
Trevor Manz: and the different capabilities that it has
Trevor Manz: within that active kernel,
Trevor Manz: it actually uses the help command.
Trevor Manz: We instruct it to use the help command
Trevor Manz: to print off the doc strings for itself
Trevor Manz: and then learn in that session
Trevor Manz: how to effectively drive Marimo.
Trevor Manz: And so this actually has a sort of decoupling
Trevor Manz: between our skill and Marimo's internals
Trevor Manz: because we don't actually publish anything
Trevor Manz: in the skill that talks about the API that it will be using.
Trevor Manz: And instead we'd say, hey, go find that when you load the skill to figure out what capabilities
Trevor Manz: that you actually have inside the active kernel.
Michael Kennedy: That's interesting.
Michael Kennedy: That way, if you want to change it, you don't have to get people to update the skill, which
Michael Kennedy: is always tricky.
Trevor Manz: Exactly.
Trevor Manz: This was the thing that we became very conscious of quite early is that updating Marimo and
Trevor Manz: updating the skill could get out of sync.
Trevor Manz: And we just wanted to make sure that our users didn't get into the state where they're having
Trevor Manz: a really poor experience using their agents because they upgraded Marimo and they hadn't
Trevor Manz: upgraded their skill. And so the skill isn't so prescriptive about exactly what the agent should
Trevor Manz: do, just more, hey, these are tools. And this is sort of the mental model of how you could drive
Trevor Manz: Marimo. And then should you want to drive Marimo, here's where you go find how to do that inside of
Trevor Manz: the active Marimo that you have in your session. Michael, I can't, I might have lost.
Michael Kennedy: Sorry. So skills have been changing over time about how they're structured and they used to be
Michael Kennedy: commands and then i don't know just the layout of these things is a little bit a little bit funky
Michael Kennedy: um i mean i guess you could manage it from marimo like have it say like hey skill update available
Michael Kennedy: push this button to reinstall it or something but it sounds pretty bare bones in terms of like just
Michael Kennedy: go talk here and then you'll figure it out when you get there sounds sounds good yeah exactly and
Trevor Manz: you know some of these like agents have the ability like for instance in Claude Code and codex
Trevor Manz: If you have this marketplace.json file where you have your skill,
Trevor Manz: you can subscribe for auto-updates of that skill
Trevor Manz: so you don't have to re-sync that file.
Trevor Manz: Or if you use one of these command-line tools for installing from GitHub,
Trevor Manz: you can install the latest.
Trevor Manz: If our users got out of sync, it's quite hard to figure out what version they have,
Trevor Manz: and maybe we'd need to do some runtime inspection.
Trevor Manz: So by really trying to have this decoupling of the skill
Trevor Manz: from the capabilities that we have inside of Marimo,
Trevor Manz: we can ensure that there's sort of a baseline of user experience.
Trevor Manz: And then should folks want to upgrade to latest skill or upgrade Marimo,
Trevor Manz: hopefully both those things should, should,
Trevor Manz: should improve that experience over time.
Michael Kennedy: Yeah, for sure.
Michael Kennedy: This portion of Talk Python is brought to you by us.
Michael Kennedy: I want to give you a quick bit of news about the courses side of Talk Python.
Michael Kennedy: Now,
Michael Kennedy: every single course at Talk Python training has full subtitles in German,
Michael Kennedy: Spanish, and Portuguese.
Michael Kennedy: That's all 283 hours completely translated, not just a couple of flagship courses.
Michael Kennedy: Just click the CC button in your player, pick your language, and you can even resize and
Michael Kennedy: reposition the captions so they don't cover the code.
Michael Kennedy: If Deutsch, Espanol, or Portuguese is your first language, this one's for you.
Michael Kennedy: Check it out at talkpython.fm.
Michael Kennedy: Just click courses in the nav bar, log in, or create an account.
Michael Kennedy: Even the free courses now come with subtitles in four different languages.
Michael Kennedy: Let's walk through installing this and maybe a quick start story.
Michael Kennedy: So first, installing it, how do we do?
Trevor Manz: Yeah, so whether or not you have a tool called...
Trevor Manz: So first of all, a skill is a folder of some files,
Trevor Manz: and there's a file called skill.md.
Trevor Manz: This is like an official specification
Trevor Manz: that you put somewhere on your file system for your agent to find.
Trevor Manz: And then there are a handful of tools that exist in open source
Trevor Manz: adding those files. And like I mentioned just a moment ago, being able to sort of upgrade those
Trevor Manz: files easily, either based off of Git syncing or by installing with one of these marketplaces. So
Trevor Manz: the way that we publish our skills, we have this repo, it's called marimoteam, marimopair.
Trevor Manz: The code that we publish there, we version over time. And you can either use, if you have the
Trevor Manz: npm package manager, you can use npxskillsadd marimoteam slash marimopair. That will start up
Trevor Manz: the command line tool to add those files to your file system. You can either install them locally
Trevor Manz: in a folder, globally on your system. If you don't have npm installed, you can actually use UV
Trevor Manz: and do uvx Dino A npm skills. And this will sort of shell out to Dino to actually install those for
Michael Kennedy: you, but you can drive it through uv. If you have pod code. I've seen this so much. I'm like,
Michael Kennedy: oh man, why are we stuck on NPM? I do have these things. So I'll put the uvx Dino dash A NPM
Michael Kennedy: I feel like that could be a sweet new alias,
Michael Kennedy: just UVNPM.
Michael Kennedy: I think that'd be nice.
Michael Kennedy: I'm going to find a way to do that.
Trevor Manz: Yeah, definitely.
Trevor Manz: Short tangent, I actually got the Dino name for the Dino folks
Trevor Manz: so we could transfer over that package.
Trevor Manz: Being able to share packages between ecosystems
Trevor Manz: without having to reinstall a new package manager
Trevor Manz: I think is really important
Trevor Manz: because both the Python ecosystem and the npm ecosystem
Trevor Manz: are growing so much.
Trevor Manz: But it's a lot to ask of users to make sure
Trevor Manz: that they have both these things installed,
Trevor Manz: especially if someone considers themselves
Trevor Manz: a node person versus a Python person.
Trevor Manz: Let's just make sure that everyone has access.
Michael Kennedy: It could be an offense to have to install npm.
Michael Kennedy: I'm not just kidding.
Michael Kennedy: So you're responsible for getting Dino as a PyPI package?
Trevor Manz: Yes, yeah.
Trevor Manz: I've collaborated a little bit with the Dino folks over the years.
Trevor Manz: I went through a very formal process with PyPy to request that name and then turn it over to them.
Michael Kennedy: Oh, that's super cool.
Michael Kennedy: So tell people real quick about Dino because they're like, well, what does that have to do with Node?
Trevor Manz: Yeah, so the creator of Dino was the same creator of Node.
Trevor Manz: And sort of the basis of Dino was, at least from the perspective of the Dino creators,
Trevor Manz: was to fix some of the things that had happened in the Node ecosystem.
Trevor Manz: And so Dino is a similar type of server-side JavaScript runtime,
Trevor Manz: but brings over a lot of functions a lot more similarly
Trevor Manz: to the way that the browser has.
Trevor Manz: So it has a lot more fine-grained permissions
Trevor Manz: baked into when you're trying to do something
Trevor Manz: like read the file system or read variables,
Trevor Manz: you have to actually explicitly opt into those capabilities
Trevor Manz: while you're executing the script
Trevor Manz: to allow that runtime to access those things.
Michael Kennedy: Okay, yeah, very nice.
Michael Kennedy: Now, do you have a preference here if I npx it or uvx it,
Michael Kennedy: or is it better to do the marketplace type of thing?
Trevor Manz: Yeah, so this starts to come down to your agent of choice.
Trevor Manz: So the npx skills is a command line tool that's published.
Trevor Manz: Skills is a package that's on the npm registry
Trevor Manz: that installs skills on your system
Trevor Manz: and sort of has a little CLI walkthrough
Trevor Manz: where you can pick multiple agents,
Trevor Manz: like if you use Codex or use Claude Code or maybe OpenCode,
Trevor Manz: where it will install them to universal directories for those things.
Trevor Manz: So if you are someone that likes to play with a lot of different agent harnesses,
Trevor Manz: I'd probably recommend using NPX or uvx Dino.
Trevor Manz: Those are semantically equivalent.
Trevor Manz: They just eventually will trigger the same CLI.
Trevor Manz: It's just the package manager that's doing it is different.
Michael Kennedy: Right, it's more npm versus plugin, exactly.
Trevor Manz: Yeah, and then the plugin is more,
Trevor Manz: that's a specific install instruction to Claude Code.
Trevor Manz: And also I believe that Codex has something quite similar.
Trevor Manz: And there you can register what's called a marketplace
Trevor Manz: for our Marimo team,
Trevor Manz: such that when we publish updates,
Trevor Manz: when you boot up Claude Code one day,
Trevor Manz: maybe it'll ask you if you'd like to upgrade our plugin.
Trevor Manz: So that will sort of keep it in sync.
Trevor Manz: So if you are a Claude Code user,
Trevor Manz: I think I'd generally recommend,
Trevor Manz: and mostly a Claude Code user,
Trevor Manz: I'd generally recommend installing from the marketplace
Trevor Manz: versus if you're someone that's flipping around
Trevor Manz: between a lot of tools,
Trevor Manz: the MPX skills does a good job
Trevor Manz: and you can MPX skills upgrade
Trevor Manz: the Marimo pair skill as well.
Michael Kennedy: Okay, that sounds really good.
Michael Kennedy: I guess, yeah, the one is general, right?
Michael Kennedy: And the one, the other,
Michael Kennedy: the plugin one is really Claude Code.
Michael Kennedy: Although I suspect if you put it into Codex,
Michael Kennedy: it might just give you a little bit of snark
Michael Kennedy: and install it.
Trevor Manz: Yeah, yeah, definitely.
Trevor Manz: I've accidentally invoked the skill with the four,
Trevor Manz: I think in Codex,
Trevor Manz: it's the dollar sign to invoke skills
Trevor Manz: and it's Claude, it's like this forward slash
Trevor Manz: and it figures it out.
Michael Kennedy: Yeah, yeah, exactly.
Michael Kennedy: You must be confused.
Michael Kennedy: This doesn't even make sense.
Michael Kennedy: What you meant to type was such and such.
Michael Kennedy: Yeah, okay.
Michael Kennedy: So is there like a getting started example
Michael Kennedy: or something like that on one of your pages
Michael Kennedy: I can sort of point at?
Trevor Manz: Yeah, so if you have the skill installed,
Trevor Manz: the best thing you can do is just spin up a Marimo session.
Trevor Manz: So you could even prompt, starting from your agent of choice,
Trevor Manz: say, start a Marimo notebook using the Marimo pair skill.
Trevor Manz: And then everything needed to actually start you pairing with Marimo
Trevor Manz: is baked into that skill.
Trevor Manz: So after you've run that uvx command,
Trevor Manz: you should be able to spin up a notebook
Trevor Manz: and then connect to it with your agent
Trevor Manz: and just start talking about some data
Trevor Manz: or talking about a notebook that you already have.
Michael Kennedy: I guess, what are some of the use cases or whatever
Michael Kennedy: that you might go through with this.
Michael Kennedy: How do you find it to be useful?
Michael Kennedy: What are you all doing with it?
Trevor Manz: Yeah, I'd say Marimo pair is increasingly the main way
Trevor Manz: that our users that prefer to author code with agents
Trevor Manz: are starting to create and share Marimo notebooks.
Trevor Manz: And so I think there are a lot of different use cases,
Trevor Manz: but the way I like to think of it
Trevor Manz: is that it really ranges from a more hands-on
Trevor Manz: versus hands-off approach to authoring notebooks.
Trevor Manz: So a more hands-on approach would be the workflow
Trevor Manz: that I just described where you spin up a notebook session, maybe you have a data set and you want to
Trevor Manz: be hands-on looking at that data, making plots, more exploratory data analysis or more iterative
Trevor Manz: where you're hands-on working with the agent. But rather than writing the code, you're sort of
Trevor Manz: prompting the code with the agent and looking at the outputs and deciding where to go next.
Trevor Manz: So that's more on the head, the interactive or hands-on approach. And then we also have a set
Trevor Manz: of users that are driving Marimo, using Marimo pair and a more headless version as well, where
Trevor Manz: they might spin off many different Marimo pair sessions
Trevor Manz: to work on a similar problem.
Trevor Manz: And at the end, they'll have these notebooks that are running
Trevor Manz: that then they can connect to and sort of check and see
Trevor Manz: what the agent was working on inside of that session.
Trevor Manz: So essentially, when you want to start a task with data,
Trevor Manz: you can open up your agent and spin up Marimo
Trevor Manz: and then start prompting towards working on that problem.
Michael Kennedy: I see.
Michael Kennedy: So maybe this headless story, like I have this data
Michael Kennedy: and I know I want some kind of description,
Michael Kennedy: exploration summary of it. So, Hey, Claude, just create a notebook and just from scratch,
Michael Kennedy: just do what you want to do to build it up. And then I'll go look at it. Right.
Michael Kennedy: Yeah. And the other ones may be more like a coding, like a data coding sort of story. Yeah,
Trevor Manz: exactly. Yeah. And the, I think the nuance there of like why the more headless approach
Trevor Manz: like works quite well with Mareem L'Apair is that if, if you've had any experience with trying to
Trevor Manz: like one shot a program or one shot a notebook in the past, the agent doesn't really have a way of
Trevor Manz: verifying what it's doing or that like that whole notebook that it created works well or maybe just
Trevor Manz: at the end can like try to run the notebook and then we'll have to go back and fix cell by cell
Trevor Manz: versus marimo pair driving from marimo pair sort of forces the agent to build up the notebooks a
Trevor Manz: similar way that you would where you would actually go cell by cell so the first thing i have to do is
Trevor Manz: like load my data the second thing i have to do is you know inspect look at my nulls and if there
Trevor Manz: are errors in any of those steps the agent will correct them there rather than sort of generating
Trevor Manz: the whole notebook and then running it from scratch. And so we found that you get much
Trevor Manz: higher quality outputs when you are actually at the time of looking at the notebook, because
Trevor Manz: the process in which the agent had to go to create the notebook sort of guarantees that it has to run
Trevor Manz: because it adheres to the Marimo's constraints versus just generating the artifact and then
Trevor Manz: saying like, hey, I'm done and didn't really check the outputs at all. Right, exactly. It just could
Michael Kennedy: be some well-formed but meaningless notebook, right?
Michael Kennedy: Yeah.
Michael Kennedy: What if I'm now we're, we're pushing up to the limits of my Marimo knowledge.
Michael Kennedy: Cause I've not tried this, but what if I got a Marimo notebook and I say, open
Michael Kennedy: up that project and VS Code, like for example, maybe I have a regular
Michael Kennedy: programming project that's VS Code that has the Claude Code installed in it, like
Michael Kennedy: the extension or whatever.
Michael Kennedy: And inside there, part of it is a Marimo notebook.
Michael Kennedy: Can I say open up that notebook in Marimo,
Michael Kennedy: but then also have Marimo pair,
Michael Kennedy: but from within the VS Code,
Michael Kennedy: Claude Code,
Michael Kennedy: or do I have got to go to the terminal?
Michael Kennedy: What is this interoperability story?
Trevor Manz: Sure.
Trevor Manz: At Marimo, I'm responsible for our VS Code extension,
Trevor Manz: which is integrated.
Trevor Manz: If you've ever tried to open up a Jupyter notebook
Trevor Manz: inside of VS Code,
Trevor Manz: VS Code or Cursor have a built-in UI for notebooks.
Trevor Manz: We have a built-in UI for notebooks
Trevor Manz: that reuses that sort of the VS Code native view,
Trevor Manz: except replacing with Maremo outputs.
Trevor Manz: And the latest thing I've been working on
Trevor Manz: is getting the ability to have your agent inside of VS Code
Trevor Manz: drive those notebook outputs as well.
Trevor Manz: So that's something we should ship
Trevor Manz: in probably the next week or so.
Michael Kennedy: And there's, of course, I guess because of economics
Michael Kennedy: or lock-in or I don't know, whatever,
Michael Kennedy: there's always, in all these editors,
Michael Kennedy: yes, even in Cursor,
Michael Kennedy: There are like first class built-in ways to do agents.
Michael Kennedy: Say in VS Code, there's like the chat thing on the right.
Michael Kennedy: Those I think is probably what they intend you to do.
Michael Kennedy: But then you can get the VS Code Claude or Codex extension,
Michael Kennedy: which is a totally different UI, but still in VS Code.
Michael Kennedy: Or you could go to the terminal and you could type Claude or Codex.
Michael Kennedy: And that's a third sort of thing, which can sort of have links back in there.
Michael Kennedy: Do some of these work and some of them don't?
Michael Kennedy: Are they all the same?
Michael Kennedy: What's the story?
Trevor Manz: Yeah, so if you're launching from the terminal
Trevor Manz: or the integrated VS Code,
Trevor Manz: sorry, the Claude Code extension from VS Code today,
Trevor Manz: that will likely start Marimo's command line tool
Trevor Manz: and then open up a web view inside of VS Code,
Trevor Manz: which is like our Marimo editor.
Trevor Manz: If you use the chat,
Trevor Manz: which is sort of the built-in agents panel inside of VS Code,
Trevor Manz: that would drive the usage of the more integrated view
Trevor Manz: inside of VS Code.
Michael Kennedy: But all three are possible, I guess, yeah?
Trevor Manz: Yeah, exactly.
Trevor Manz: You can start a Marimo pair session
Trevor Manz: from any of those panels.
Trevor Manz: It's just a matter of what the visual
Trevor Manz: that you're looking at is,
Trevor Manz: if that's going to be the native VS Code editor
Trevor Manz: for the notebook versus a web view
Trevor Manz: of the Marimo notebook UI.
Michael Kennedy: Yeah, and my sort of huff at this before was like,
Michael Kennedy: This is only here because Claude Code won't allow you to use your subscription in the other one.
Michael Kennedy: It's got to be, you know, in certain circumstances, right?
Michael Kennedy: Like, oh, if you use the official extension, you can use your subscription.
Michael Kennedy: But if you use this other way, then you've like, say in Cursor, you use your Cursor credits, not your Claude Code subscription.
Michael Kennedy: 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.
Trevor Manz: 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.
Trevor Manz: And so from our perspective, we think there will likely be a continued amount of drift between these different tools.
Trevor Manz: 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.
Trevor Manz: but we do think Marimo as an environment for working with your data should be accessible from
Trevor Manz: whatever tool that you choose. And so on our side, we just want to make sure that you're able to
Trevor Manz: connect to and drive a Marimo notebook from your agent harness and tool of choice.
Michael Kennedy: I think in maybe some kind of idealistic, non-realistic world where all the frontier
Michael Kennedy: foundation coding models, you could just tell it your subscription or tell it whatever,
Michael Kennedy: and it's the same billing everywhere,
Michael Kennedy: it might be better to have some kind of built-in panel
Michael Kennedy: into Marimo or little pop-ups or something.
Michael Kennedy: But given all the weird restrictions and stuff,
Michael Kennedy: it seems like a really good plan
Michael Kennedy: to just have Marimo good at talking to any agent
Michael Kennedy: through this way and however people want to run it,
Michael Kennedy: they can just talk to it, right?
Trevor Manz: Yeah.
Trevor Manz: It's been challenging because we spend a lot of time
Trevor Manz: on that UI and thinking about that UI
Trevor Manz: that we own inside of Marimo
Trevor Manz: how this should work with these agents.
Trevor Manz: But the reality is that there's a lot of friction.
Trevor Manz: And if we would have tried to build around
Trevor Manz: Claude Max like a year ago,
Trevor Manz: that would have been a lot of wasted effort
Trevor Manz: because of the way that these platforms are changing.
Trevor Manz: So as these tools become increasingly sticky
Trevor Manz: and folks get entrenched into their agents of choice,
Trevor Manz: I think from our perspective,
Trevor Manz: making sure Marimo remains a useful tool
Trevor Manz: to any agent is really our priority.
Trevor Manz: And if there is some sort of...
Trevor Manz: yeah, future day where we can own that UI again, then I think we will certainly have a story there.
Michael Kennedy: Yeah, I think I totally agree with you, but I want to share a little graph with you from the
Michael Kennedy: Pragmatic Engineer newsletter. Yeah, I guess newsletter. So if you, there's this one that was
Michael Kennedy: AI tooling for software engineers in 2026. So you scroll down till we see a graph. There we go.
Michael Kennedy: If you look at what people are using, it's Claude Code.
Michael Kennedy: 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.
Michael Kennedy: But I feel like this is primarily used because companies have Microsoft 365 subscriptions and they've got 10,000 employees.
Michael Kennedy: And they're like, you can use Copilot because it's approved.
Michael Kennedy: I don't know that that's necessarily what people are seeking out as their top choice.
Michael Kennedy: I don't know, I could be wrong.
Michael Kennedy: Sorry if I got that wrong, Copilot folks.
Michael Kennedy: But, and then maybe about half is Cursor
Michael Kennedy: and that's kind of its own world and then it goes Codex.
Michael Kennedy: So like, I feel like if you're trying to,
Michael Kennedy: this is like Claude Code was way behind a year ago.
Michael Kennedy: It's crazy.
Michael Kennedy: So I feel like if you're building a tool,
Michael Kennedy: especially for developers that says,
Michael Kennedy: let's pretend you don't want this.
Michael Kennedy: Let us give you our version of something that's like it.
Michael Kennedy: I just don't think that that's a road for success.
Michael Kennedy: I think you're fighting against like,
Michael Kennedy: everyone's like, you know what, we're in Claude Code and it works really well. Why am I going to
Michael Kennedy: go put that away and use your thing? As opposed to what you guys built, which is like, well, here's
Michael Kennedy: how you use the top three of those things to talk to what you're already doing. I think that's a good
Trevor Manz: choice. Yeah, I think for us, it was the realization that the effectiveness of agents on a particular
Trevor Manz: task is a combination of like, I think an agent is by definition is like a model, the tools that you
Trevor Manz: equip that model with and then its environment or the loop that it runs in to perform that task.
Trevor Manz: And so its effectiveness is going to be limited by whatever tools you give that agent.
Trevor Manz: And so if we didn't make Marimo a useful tool for the agent, then if you give a data problem
Trevor Manz: to the agents, it's going to use the tools that it has at hand, which are reading and writing files
Trevor Manz: and running bash scripts. If you run that script a bunch of times or you ask the same data question
Trevor Manz: using those tools, you might get a folder with a lot of different scripts and things and maybe a
Trevor Manz: result. And so by giving agents, or really thinking of Marimo as a tool for agents,
Trevor Manz: then we don't have to think so much about the interface for the agent, but rather just how to
Trevor Manz: expose our environment to agents. And then when you ask for those data tasks, the thing that you
Trevor Manz: generate at the end is this reproducible Python program that is a Marimo notebook, but you can
Trevor Manz: drive that for many of these UIs of choice. And I look at these bars here, there's going to be
Trevor Manz: jumping back and forth between these, depending on what the providers dictate in terms of their
Michael Kennedy: Who gets blocked by the US government, who doesn't?
Trevor Manz: Exactly.
Trevor Manz: For us at Marimo, as long as we can make sure that regardless of what agent you use,
Trevor Manz: you will have notebooks as a useful tool.
Trevor Manz: Then at the end of the day, you're still just generating Marimo notebooks.
Trevor Manz: Even if you turn off your agent, you have this reproducible artifact
Trevor Manz: that is useful for communicating your data results
Trevor Manz: or something about what happened in that session while you're working with data.
Trevor Manz: That's our goal at Marimo,
Trevor Manz: to make sure that whether you knew how to write Python code
Trevor Manz: or you don't know how to write Python code,
Trevor Manz: you're able to produce this reproducible artifact
Trevor Manz: for your data analysis.
Michael Kennedy: Okay.
Michael Kennedy: You also talked about open code AI.
Michael Kennedy: This is somewhat new to me.
Michael Kennedy: What is this open code thing?
Trevor Manz: Yeah, so open code is similar.
Trevor Manz: I think Claude Code had the first form factor
Trevor Manz: of being one of these terminal CLIs that you spin up.
Trevor Manz: but just with the Anthropic models.
Trevor Manz: And then OpenCode is a similar,
Trevor Manz: like it feels very similar to using Claude Code,
Trevor Manz: but it allows you to configure a lot of different models
Trevor Manz: that have the ability to configure API endpoints.
Trevor Manz: So for a while,
Trevor Manz: I believe you can still configure all the different providers.
Trevor Manz: It's just like the type of subscription models
Trevor Manz: that you can use with OpenCode change quite a bit,
Trevor Manz: similar to what you were just mentioning inside of VS Code.
Michael Kennedy: Yeah, for example, it looks like you can use your Codex subscription, but not your Claude subscription.
Trevor Manz: Yeah, exactly.
Trevor Manz: 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.
Trevor Manz: If you type in OpenCode, you'll get a window.
Trevor Manz: You can start prompting.
Trevor Manz: You can also install skills for OpenCode as well, the same way that you install for any of these harnesses.
Trevor Manz: But we had some users that use OpenCode because of the open models.
Trevor Manz: We have some users that are using Claude Code.
Trevor Manz: We have some users that are using codex or VS Code.
Trevor Manz: And like I mentioned, we just want to make sure that anyone can drive a Marimo notebook.
Michael Kennedy: So it must be tough to be supporting AI stuff in this space, given how much flux it's under.
Trevor Manz: Yeah, I think by inverting the problem in so far is that we are no longer like, you know,
Trevor Manz: by moving some of this ability to drive Marimo outside of the Marimo UI, we don't have to
Trevor Manz: keep up as much with all the fluctuation in the new models.
Trevor Manz: 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.
Trevor Manz: 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.
Michael Kennedy: Sure, sure, sure.
Michael Kennedy: So having this, how does this change how people use notebooks?
Michael Kennedy: I know how it's changed coding.
Michael Kennedy: It's changed it quite a bit in some ways and not at all in others.
Michael Kennedy: But how about for data?
Trevor Manz: That's a really good question.
Trevor Manz: So I mentioned earlier that part of the value of these environments
Trevor Manz: like a Marimo notebook or like a Jupyter or Excel
Trevor Manz: is the statefulness of those environments.
Trevor Manz: And so it's really like there's a lot of, you know,
Trevor Manz: when you're using an agent,
Trevor Manz: it's able to gather things and put it from your file system
Trevor Manz: to bring that into context or from the web
Trevor Manz: to be able to, when you ask a prompt,
Trevor Manz: perform a task that hopefully fulfills that
Trevor Manz: to some sufficient level.
Trevor Manz: And prior to having an integration like Marimo pair,
Trevor Manz: that statefulness could be,
Trevor Manz: basically the values that are in memory
Trevor Manz: could be extra context to helping the agent
Trevor Manz: answer some question,
Trevor Manz: but you'd sort of have to babysit the model
Trevor Manz: or tell it something like, oh, I copied this output,
Trevor Manz: here's the output.
Trevor Manz: And now when you say, what's in this data frame,
Trevor Manz: it can look at those columns for you.
Trevor Manz: Or for example, if I'm doing something like EDA type of analysis
Trevor Manz: inside of Marimo, I can circle on a plot and make a selection.
Trevor Manz: And I can say, what did I just select here?
Trevor Manz: And the agent can go take that indice selection that I made,
Trevor Manz: compare it against the data frame,
Trevor Manz: and come back to me with some answer.
Trevor Manz: So I think these types of questions that maybe felt tedious
Trevor Manz: to ask before, like, because you'd have to type out a lot of code to do that.
Trevor Manz: Now you can really either use the agent to help you write code or actually ask you questions
Trevor Manz: about the state inside that notebook.
Trevor Manz: And you're really extending the agent's, you know, environment with the intermediate values
Trevor Manz: that, you know, as a human might find interesting.
Trevor Manz: But now the agent can also use that as potential context.
Michael Kennedy: One of the things I think is super useful.
Michael Kennedy: A lot of times I feel like people maybe miss this and maybe, maybe more people than I realize
Michael Kennedy: know about it, but in VS Code or PyCharm or cursor, I think cursor might be best as I'm not
Michael Kennedy: entirely sure these days, but anyway, if I've got a file, maybe I've got hundreds of files in my
Michael Kennedy: project, but a particular file I'm interested in, if I have that file open and I ask questions,
Michael Kennedy: it's automatically included as context, just by virtue of having it be the last focused file.
Michael Kennedy: But even better is you can highlight parts of a line or three lines or whatever and go,
Michael Kennedy: what's wrong with this?
Michael Kennedy: It's all you got to say.
Michael Kennedy: And it goes, oh yeah, I see the function
Michael Kennedy: that you're talking about,
Michael Kennedy: the part that you've highlighted,
Michael Kennedy: like boom, off it goes.
Michael Kennedy: Is there some mechanism?
Michael Kennedy: It sounds a little bit like there is,
Michael Kennedy: but is there a mechanism in Marimo
Michael Kennedy: that it communicates back what's active,
Michael Kennedy: what you're working with?
Trevor Manz: Yeah, so we have, you know,
Trevor Manz: as the agent is running things,
Trevor Manz: we can communicate, you know,
Trevor Manz: what cells have changed
Trevor Manz: or like if there are values
Trevor Manz: that have changed in the notebook
Trevor Manz: and then the agent can go and ask questions
Trevor Manz: about those things that have changed.
Trevor Manz: We have some folks in our team that are working on creating these sort of,
Trevor Manz: like I think to what you're mentioning,
Trevor Manz: imagine you highlight a line of code and you want to feed that back
Trevor Manz: as potential context of here's where I'm focusing.
Trevor Manz: Inside of a notebook, if you're using actually the integrated browser
Trevor Manz: inside a VS Code or cursor, you can actually click on a plot
Trevor Manz: and it'll take that screenshot and it'll add it as context
Trevor Manz: to what you're going to ask.
Trevor Manz: And so now you're having this interaction where it's not just the values
Trevor Manz: but also the outputs and the visual outputs that you can say,
Trevor Manz: hey, this is a little bit weird.
Trevor Manz: I see this, this, and this.
Trevor Manz: So we're definitely thinking that direction
Trevor Manz: where, yeah, it's not just the line of code,
Trevor Manz: but the value of the code
Trevor Manz: and the representation of the code
Trevor Manz: that could actually feed back
Trevor Manz: to these multimodal models
Trevor Manz: and help you sort of come to better understanding
Trevor Manz: quickly with your data.
Michael Kennedy: Yeah, awesome.
Michael Kennedy: I love it.
Michael Kennedy: It's so nice because instead of trying
Michael Kennedy: to just like describe,
Michael Kennedy: okay, and the third function called this,
Michael Kennedy: there's a part where there's an if,
Michael Kennedy: you know, just like highlight and go this, right?
Michael Kennedy: It's great.
Trevor Manz: Exactly.
Trevor Manz: There's a certain level of interactions
Trevor Manz: or feeding back of...
Trevor Manz: I think when I started to realize
Trevor Manz: that these agents could be very powerful
Trevor Manz: was when coding tasks started to feel a lot cheaper.
Trevor Manz: Like maybe these what-if ideas
Trevor Manz: of something I wanted to try with software,
Trevor Manz: I could, rather than that taking up a whole weekend
Trevor Manz: or several weeks to try out,
Trevor Manz: it's like maybe an afternoon I could try that out.
Trevor Manz: And I think the experience that we want to provide
Trevor Manz: for our users inside of Marimo Notebooks
Trevor Manz: is that these kind of what-if questions with your data
Trevor Manz: also feel very cheap.
Trevor Manz: So you say, what is that?
Trevor Manz: 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.
Trevor Manz: And now you can just like start to ask those questions and hopefully get to insight more quickly.
Michael Kennedy: 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?
Michael Kennedy: If you were actually paired programming, you could just highlight something on the screen and go, what do you think about this?
Michael Kennedy: Right. Where's sort of the traditional, I don't know, Claude code just in the terminal.
Michael Kennedy: You've got to describe it a lot, talk about the file, right?
Michael Kennedy: Like you can't just have it sort of ambiently there.
Michael Kennedy: And if you're sitting there working with these tools, these agentic tools all day,
Michael Kennedy: especially if you're not doing a lot of programming with other people, like it's
Michael Kennedy: primarily the, you're sort of coding partner, you know, your paired programmer or
Michael Kennedy: whatever, the more you've kind of got to artificially step out and say, yeah,
Michael Kennedy: over on this file at dah, dah, dah, dah, try to find the file.
Michael Kennedy: And then you're talking about this, right?
Michael Kennedy: It breaks this flow and this idea of this thing is here to help me.
Michael Kennedy: It's like, I'm just sending stuff to this dumb machine
Michael Kennedy: that can't really figure out what's going on.
Michael Kennedy: So I really like it.
Michael Kennedy: This concept you're talking about.
Trevor Manz: I had this experience where I was actually trying to help my dad
Trevor Manz: look at some data that he had in Excel.
Trevor Manz: Notoriously, that's very annoying to load an Excel file in Python
Trevor Manz: because you end up writing your own little parser
Trevor Manz: to figure out the different subsets of the tables.
Trevor Manz: At the end of the day, what I really wanted were a couple data frames
Trevor Manz: plot inside of the notebook. And being able to just drag from my UI the Excel file over into
Trevor Manz: Marimo pair and saying, hey, can you just load these three tables inside the notebook and let
Trevor Manz: the agent chug away in the notebook at trying to figure out how to create those plots for me?
Trevor Manz: Maybe that would have taken me an hour to do on my hand from before. And it took a couple minutes
Trevor Manz: for the agent or maybe even a minute for the agent. And then I got to focus on the exciting
Trevor Manz: part was how to make these plots and communicate something with the data. So automating those pieces
Trevor Manz: that are very bespoke and kind of annoying of like, how do you get data formats into the notebook is
Trevor Manz: now something you can sort of, you know, task the agent on for a little bit. Right. I'm not a fan of
Michael Kennedy: vibe coding really, but I do think this provides really interesting onboard, like on ramps for
Michael Kennedy: people to get into notebooks and programming and so on. Cause maybe they can ask decent questions
Michael Kennedy: about data, but they can't necessarily go, okay, I'm going to get the pie X amount, the XML,
Michael Kennedy: XLS writer or whatever it is. Right. As you can tell, I don't remember exactly the name of it.
Michael Kennedy: So there you go.
Michael Kennedy: All right, that kind of thing.
Michael Kennedy: And just like load this up and then let's talk about it.
Michael Kennedy: Like I know what a data frame is,
Michael Kennedy: but I really need to know how to like select the third sheet in Excel.
Michael Kennedy: Yes, exactly.
Trevor Manz: Do I need to know that API to like get my tasks done
Trevor Manz: with these data inside the notebook?
Trevor Manz: And I think, you know, for in this context as well,
Trevor Manz: because Marimo has this, you know,
Trevor Manz: this deterministic execution order,
Trevor Manz: you can sort of collaborate on building, you know,
Trevor Manz: this like this reproducible like workflow
Trevor Manz: of how you got to that notebook.
Trevor Manz: So you can, instead of vibe coding the whole thing,
Trevor Manz: you can maybe allow someone to kind of vibe code
Trevor Manz: the first bit of how do we get the data into memory?
Trevor Manz: And then the things that really require attention
Trevor Manz: about cleaning up the data and plotting the data
Trevor Manz: and running some modeling on that data,
Trevor Manz: now you've sort of freed up your time
Trevor Manz: to focus on those bits as well.
Michael Kennedy: Yeah, 100%.
Michael Kennedy: It lets you focus on the parts that actually matter,
Michael Kennedy: not just silly file formats and stuff like that, right?
Trevor Manz: Yeah.
Trevor Manz: And we're lucky because Python's such a Swiss army knife
Trevor Manz: to all that has such a rich ecosystem
Trevor Manz: of ingesting data and working with data
Trevor Manz: that you can lean on that ecosystem
Trevor Manz: plus the agent inside of the notebook
Trevor Manz: to get your data into a format that is useful.
Trevor Manz: But then that's the point that you step in
Trevor Manz: and start to direct more about what direction
Trevor Manz: you want to take that analysis.
Michael Kennedy: Totally.
Michael Kennedy: So a couple of final questions
Michael Kennedy: to wrap up our conversation here.
Michael Kennedy: Tips and tricks for people like,
Michael Kennedy: okay, you've got the skill, you've got Marimo.
Michael Kennedy: Are there interesting things you've all discovered you can do
Michael Kennedy: that maybe are non-obvious?
Michael Kennedy: Tips and tricks.
Trevor Manz: Honestly, my recommendation would be to,
Trevor Manz: if there is some data set that you have in mind,
Trevor Manz: like the example I mentioned with an Excel file,
Trevor Manz: it's a very fun task to just drag in a data set and say,
Trevor Manz: please load this for me inside the notebook
Trevor Manz: and let's start making some plots or something.
Trevor Manz: And I think very quickly you'll realize
Trevor Manz: how quickly this runtime inspection
Trevor Manz: really shapes this user experience
Trevor Manz: where I think I went from being very hands-on
Trevor Manz: with working in notebooks
Trevor Manz: to being able to sit back a little bit more
Trevor Manz: and think cell-by-cell about what I want to do.
Trevor Manz: So I just encourage folks to try it out with their data
Trevor Manz: and let us know what they run into.
Michael Kennedy: Okay, yeah, that makes a lot of sense.
Michael Kennedy: One thing that I've done before,
Michael Kennedy: just playing around with data,
Michael Kennedy: is I've asked Claude,
Michael Kennedy: like, hey, here's the data, here's the scenario.
Michael Kennedy: What are some interesting questions
Michael Kennedy: we should be asking about it?
Michael Kennedy: here's what I think is interesting, but what am I missing?
Michael Kennedy: Are there trends in the data that I don't see that maybe you can pull out
Michael Kennedy: and just kind of have it just cruise around and just think about it a little bit?
Michael Kennedy: And it was really good.
Trevor Manz: Yeah, and I think you can imagine extending that.
Trevor Manz: Typically when you're maybe asking those questions back and forth with Claude,
Trevor Manz: it's giving you some tables and numbers and distributions in the data.
Trevor Manz: But because when you're connected to a Marimo kernel,
Trevor Manz: now you can ask for plots or different visual representations
Trevor Manz: that might be able to show those trends.
Trevor Manz: So if the agent is telling you
Trevor Manz: that there is this difference,
Trevor Manz: you could say, hey, make a bar chart
Trevor Manz: or a box plot for me to understand that information.
Trevor Manz: Because you do just have this much richer canvas
Trevor Manz: for talking about your data
Trevor Manz: rather than just the ASCII output in your terminal.
Michael Kennedy: Right, the first thing that I got
Michael Kennedy: was a bunch of data frames and heads
Michael Kennedy: or stats or something like that.
Michael Kennedy: And I'm like, this is great,
Michael Kennedy: but describe this in pictures.
Michael Kennedy: And then I had a bunch of graphs.
Michael Kennedy: And I'm like, okay, that was cool.
Michael Kennedy: That was really cool.
Michael Kennedy: Maybe people could try that, right?
Michael Kennedy: Definitely.
Michael Kennedy: All right, roadmap.
Michael Kennedy: Where are things going?
Trevor Manz: Yeah, so as I mentioned,
Trevor Manz: we are currently building a tighter integration
Trevor Manz: with our native editor inside of VS Code.
Trevor Manz: So essentially our direction with Marimo Pair
Trevor Manz: is to try to think of all the places
Trevor Manz: in which folks are trying to drive agents
Trevor Manz: that maybe we could have the ability
Trevor Manz: to spin up a Marimo notebook
Trevor Manz: and allow folks to collaborate
Trevor Manz: on these reproducible artifacts.
Trevor Manz: So right now that looks a lot like
Trevor Manz: more terminal oriented workflows.
Trevor Manz: We have some integration now
Trevor Manz: inside the Marimo editor itself,
Trevor Manz: like I mentioned,
Trevor Manz: where you can open up the chat
Trevor Manz: and start using Marimo pair.
Trevor Manz: We'll have a further integration into VS Code.
Trevor Manz: And I think down the line,
Trevor Manz: we'll have eventually,
Trevor Manz: you know, if you're using Cloud Desktop
Trevor Manz: or Codex Desktop,
Trevor Manz: that maybe you can start your little chat there.
Trevor Manz: And that could also drive a Marimo notebook as well.
Michael Kennedy: I feel like that's an entirely missing piece
Michael Kennedy: of this whole agentic AI world,
Michael Kennedy: like the Google Docs CoLab equivalent, right?
Michael Kennedy: Like I've started up Claude Code
Michael Kennedy: or something like that.
Michael Kennedy: And now, why don't you join my session?
Michael Kennedy: We'll all talk to Claude and, you know, have it go.
Michael Kennedy: I don't know, maybe someday.
Trevor Manz: Yeah, or maybe Maremo can serve.
Trevor Manz: Like, you know, we will have,
Trevor Manz: we are currently working on some real-time collaboration features
Trevor Manz: inside of Maremo.
Trevor Manz: And maybe there's some way that, you know,
Trevor Manz: multiple people have multiple agents that are talking to the same
Michael Kennedy: Maremo kernel.
Michael Kennedy: Each person with their agent buddy are all in there.
Michael Kennedy: That seems totally reasonable as long as it's, you know, aware.
Michael Kennedy: What about remote?
Michael Kennedy: So I'm running Marimo, I'm not on my machine,
Michael Kennedy: but on some server or some cloud service or whatever,
Michael Kennedy: but I've got my cloud local and I want to have those things work together.
Trevor Manz: Yeah, so the way that behind the scenes,
Trevor Manz: like how the tool call works inside of Marimo,
Trevor Manz: it's a bash script that's called execute code.
Trevor Manz: That allows you to swap in a URL, whether that's on local host
Trevor Manz: or something remotely with some authentication.
Trevor Manz: And therefore you can connect your local cloud
Trevor Manz: to some remote Marimo kernel as well.
Trevor Manz: And then you have a sandbox that's not running on your machine at all, but somewhere in the cloud.
Trevor Manz: But you're driving that from your local machine.
Michael Kennedy: Some big machine with GPUs or whatever, that's a better place to run your code.
Trevor Manz: Yeah, exactly.
Trevor Manz: At Marimo, we have a cloud-hosted version of Marimo Notebooks that's called Molab
Trevor Manz: that we recently released on CoreWeave Infrastructure, where we have some GPUs for our community.
Trevor Manz: And you can actually today go inside that UI and click pair with an agent,
Trevor Manz: And you can copy a little cloud command
Trevor Manz: and connect that to your Claude Code or your codex.
Trevor Manz: And then you can start pair programming locally
Trevor Manz: with that remote sandbox in the cloud.
Michael Kennedy: I love it. That's awesome.
Michael Kennedy: All right, final call to action.
Michael Kennedy: People are like, Marimo pair sounds cool.
Michael Kennedy: What do you tell them? How do they get started?
Trevor Manz: Yeah, so I'd recommend going to marimo.io slash pair,
Trevor Manz: grabbing the skill and spinning up a notebook of your own
Trevor Manz: and just trying to do tasks that you do with data.
Trevor Manz: Traditionally, maybe in a notebook
Trevor Manz: or maybe if things haven't been going well inside that notebook.
Trevor Manz: We haven't put up the site yet.
Michael Kennedy: That's right, it's coming soon.
Michael Kennedy: I totally forgot you said that.
Michael Kennedy: By the time this episode comes out, that will be there.
Trevor Manz: If you're watching the live stream, maybe give it a few days.
Trevor Manz: By the time this episode comes out, check out marimo.io.
Trevor Manz: Or go to our GitHub for marimo pair, install the skill,
Trevor Manz: and show us what you build with Marimo,
Trevor Manz: regardless of if you're driving it with agents.
Trevor Manz: But we'd love to hear if you start using out agents
Trevor Manz: where the skill falls short
Trevor Manz: and how we can really improve that user experience.
Michael Kennedy: Cool.
Michael Kennedy: Well, it seems like a really neat idea.
Michael Kennedy: I think you're going to have a lot of success with it.
Michael Kennedy: So thanks for coming on the show
Michael Kennedy: and sharing it with everyone.
Trevor Manz: Yeah, thanks so much for having me, Michael.
Michael Kennedy: Yeah, you bet.
Michael Kennedy: Bye.
Michael Kennedy: This has been another episode of Talk Python To Me.
Michael Kennedy: Thank you to our sponsors.
Michael Kennedy: Be sure to check out what they're offering.
Michael Kennedy: It really helps support the show.
Michael Kennedy: This episode is brought to you by Sentry.
Michael Kennedy: You know Sentry for the air monitoring,
Michael Kennedy: but they now have logs too.
Michael Kennedy: And with Sentry, your logs become way more usable,
Michael Kennedy: interleaving into your error reports to enhance debugging and understanding.
Michael Kennedy: Get started today at talkpython.fm/sentry.
Michael Kennedy: If you or your team needs to learn Python,
Michael Kennedy: we have over 270 hours of beginner and advanced courses
Michael Kennedy: on topics ranging from complete beginners to async code,
Michael Kennedy: Flask, Django, HTML, and even LLMs.
Michael Kennedy: Best of all, there's no subscription in sight.
Michael Kennedy: Browse the catalog at talkpython.fm.
Michael Kennedy: And if you're not already subscribed to the show on your favorite podcast player,
Michael Kennedy: what are you waiting for?
Michael Kennedy: Just search for Python in your podcast player.
Michael Kennedy: We should be right at the top.
Michael Kennedy: If you enjoy that geeky rap song, you can download the full track.
Michael Kennedy: The link is actually in your podcast player show notes.
Michael Kennedy: This is your host, Michael Kennedy.
Michael Kennedy: Thank you so much for listening.
Michael Kennedy: I really appreciate it.
Michael Kennedy: I'll see you next time.
Thank you.