Meet Goose, an Open Source AI Agent
Summary
- AI Agent Framework: Goose is an open-source AI agent that connects language models to real-world actions across any system through simple extensions.
- MCP Integration: Built on the Model Context Protocol developed with Anthropic, Goose transforms natural language into actions across tools like Jira, GitHub, and system commands.
- Developer-Friendly Deployment: Available as both a command-line interface and desktop application, Goose enables anyone to build agentic workflows without IDE limitations.
Meet Goose, an Open Source AI Agent

Talk by Bradley Axen, Principal AI Engineer, Block
goose is an open source AI agent framework that allows anyone to connect language model output to real world action. Released in January by Block (the company made up of Square, Cash App, Afterpay, and TIDAL), its use cases range from vibe coding to connecting all of the internal apps and services an enterprise uses. It can be powered by any language model that has tool calling capabilities.
goose's modular design allows it to connect with any system through simple extensions. Built on the open Model Context Protocol (developed with Anthropic), goose transforms natural language into actions across various tools and services. Whether integrating with platforms like Jira and GitHub, or executing system commands and scripts, its plug-and-play architecture means anyone can extend Goose's capabilities to suit their needs.
Finally, goose has both a command line interface and desktop app — it isn't limited to an IDE to start connecting to MCP servers and building powerful agentic workflows.
Databricks Named a Leader in the 2025 Gartner® Magic Quadrant™ for Data Science and Machine Learning Platforms: https://www.databricks.com/blog/databricks-named-leader-2025-gartner-magic-quadrant-data-science-and-machine-learning
Build and deploy quality AI agent systems: https://www.databricks.com/product/artificial-intelligence
See all the product announcements from Data + AI Summit: https://www.databricks.com/events/dataaisummit-2025-announcements
Chapters
0:00Intro1:12Demo5:13How it works11:25Working for developers14:48Using Goose to build an Android app16:43Using Goose in an enterprise context20:32What makes Goose different24:38The biggest value of Goose27:50Nondeveloper adoption of Goose29:04Open Source31:02Recap
FAQs
What is Goose AI agent framework?
Goose is an open-source AI agent developed by Block that allows anyone to connect language model output to real-world action. It was released in January and has a modular design that can connect with any system through simple extensions.
How does Goose integrate with different tools?
Goose is built on the open Model Context Protocol (MCP) developed with Anthropic, which transforms natural language into actions across various tools and services. It can integrate with platforms like Jira and GitHub, execute system commands, and work with any system through custom extensions.
What interfaces does Goose support?
Goose has both a command-line interface and desktop application, so it isn't limited to an IDE for connecting to MCP servers and building agentic workflows.
Which language models can power Goose?
Goose can be powered by any language model that has tool calling capabilities. At Block, their setup includes Anthropic LLMs like Sonnet, as well as OpenAI and Gemini models.
Full transcript
0:00 Intro
Hello everybody. I can see that is working. Um I'll I'll get us started, but I'll I'll mention that we uh we should have about 10 extra minutes at the end for questions and also feel free to interrupt in the middle if you want to clarify anything. Um uh but with that I'm Brad Axen uh and I'm a principal engineer at Block which you probably know better as the company that uh has Square and Cash App and Title. Uh and for the last couple of years I've been working on AI and I'm going to be talking about a project of ours called Codename Goose which is an open- source general purpose AI agent.
Um, I mentioned open source. So, this is used by a lot of developers and it's a a pretty pretty popular tool uh in the kind of coding space, but I'm going to be focusing today more on how we use it at a company like Block to help us automate what we do. And I think that's really relevant for a lot of the people here because you probably also work uh at a tech company uh and have some of the same problems I imagine that we face.
Um, so with that, let me dive into first a demo so that you can see what goose actually looks like when it's working. Um, first I'm going to hop from the chat window into the settings page just to show you all that goose is really based around the extensions that it can operate. So everything that goose does is a tool that's executed through MCP, which I'll talk more about later. And when I'm using goose at block, I have something like 50 different extensions enabled.
1:12 Demo
So today we're going to use just a few of those. Uh, and the first thing I'm going to ask Goose to do is get us a summary of our internal usage uh, of Goose. And so, because I have all of those extensions enabled and I can I have access to our databases and it has a little bit of knowledge about our company, it jumps right into turning on the datab bricks extension and it immediately goes into writing queries and it can do all of that without asking me or for approvals because I've got it running in autonomous mode.
Uh, but there's other options there. So you can say like I need manual approval of every tool or I just want to chat and while it's working I'll I'll mention that uh we have a lot of different models that we've enabled. So this is intended to work with any different LLM that you've got access to. So in our setup we have access to anthropic LLMs. This is currently using sonnet but there's a bunch of open AAI stuff uh and even Gemini in there.
Okay. So, while I've been giving you a little UI tour, Goose has been working in the background on actually solving that problem that I told it to do. It does that by first, you can see in the history, it describes the tables that it's going to use to get that information from. And then it goes into writing queries. Uh along the way, its context window is filling up as it's getting those results. So, it actually sees the result of running the query and it uses that to figure out like what additional information it needs.
And it gets back to us with this usage summary. So we have had 9 million requests go through goose and around 9,000 users internal to block. Uh and in that time there's been about two and a half million tool calls. Um okay so that's not it. It doesn't just work with data. It can really do anything. So I'm going to ask it first to take a screenshot of itself. I want it to understand what it looks like so that we can use its own design as a reference to build a web page.
We're going to make a little dashboard and I've told it to try to make it look like in line with its own theme. And so at this point, it's actually going to start writing code. So this demo is not sped up at all. This is running in real time. And as it was going through those queries, you saw it was iterating pretty quickly because queries are small. Now it's taking a little longer as it writes the HTML code to power a full web page.
But compared to me writing that myself, it's quite a bit faster. So in a couple of seconds, we should see that pop up. And in addition to actually writing the code, it's able to do things like run shell commands. So when it's done, which it just landed, it's going to open that up for me. And I'm going to see a little website that does look a lot like the design we were just looking at. And it's showing all the same summary stats.
We get a little more info here. Like we had 5,000 people using it last week. Um, the other thing that's like important to see here in the UI is that wasn't like a pre-baked website. It just literally made all of that HTML code on the fly and it kind of did a oneshot pretty good job. Uh, and this is actually scrolling through all of the CSS it wrote to figure out the design. Uh, and then the HTML components there. And so this is kind of the normal way that we uh see people using Goose, which is not it's not really an editor.
It's more of a thing that you give a complete task and you let it run with that for you uh and then come back and look at the results. And I'll go into some more examples of that in a couple minutes. Um, but yeah, that's a quick tour of the UI. Um, we also have a command line version of this which is pretty popular among developers uh because it's more portable. So you can run that um you know on Linux or on Windows and also I think increasingly importantly that's a thing that we run in CI workloads or in automated endtoend uh settings.
So let me talk a little bit about how we make the agent work. Um, and I I feel like I have to do this talk because you've probably heard a bunch of other talks about agents today already. And uh, everybody has a different implementation of what an agent means. So for us, it's really about the autonomous loop that the agent operates uh, so that it can turn that incoming human request into actions in downstream systems.
5:13 How it works
Um, so what we're showing here is you as a person are going to pop into the goose UI or the CLI and you're going to ask it to do something for you. Uh, that is going to result in potentially minutes worth of work from the LLM where it's responding to the environment it sees uh, and it makes progress and tries to solve the problem end to end. So let me go through the steps a little bit. The first thing that happens is that we call out to a provider and in goose when we say provider we're we're talking about open AAI or Anthropic or even data bricks somebody who's hosting a model and giving you this like chat API which is kind of the building primitive that most of these agents are based off of.
So at a low level that's just text to text but at this point pretty much all of the providers have a mechanism for specifying a tool call which under the hood that's just lines of JSON but they extract it for you and make sure that it's valid. So what happens after the human request comes in and we've made a call to the LLM is we get back some sort some sort of tool call which is effectively just what function are we going to execute and what are the arguments to that function.
Uh really straightforward but it can do almost anything. So in that demo you were seeing goose uh edit files. So that's like the function call is text edit and the args are the content of the file. Uh we also have shell commands right. So you can really like turn this into any general purpose system that you want it to operate. Um, in this point it's just text. So the extension that goose does on top of the model providers is to actually route those tools to the system that can execute them and then run it.
Uh, so in that case a lot of those extensions that I was talking about in the settings page, some of them are bundled with goose like editing files and running shell commands on your own laptop. But um you can extend that in a lot of ways and I'll go into some detail about how we work with MCP to do those extensions later. Uh but you can think of it as a very large library of tools that goose might operate in the in my setup.
It's hundreds and so a lot of the work in the agent is kind of reducing the scope down to just what it needs at the moment that it's that it's operating. Um so picking the right tool effectively. Another thing that is really important in our architecture is that uh a tool call can fail and that's kind of normal operations. We don't want the loop to exit if a tool call fails. We want that to just be raised as feedback to the LLM.
So say it does some wrong action. It can then pretty quickly recover from that. Most of these LLMs are good enough to diagnose their own errors and keep making progress as things fall apart. Uh, and that's like a pretty important performance component in our system. So, we go out of our way to take every possible failure mode and turn it into a message that the LLM can respond to and diagnose and fix. Okay, one more critical component uh on this diagram is this like tiny box that says revise context.
That's a really hard thing to do right with AI agents. Um, even though the model providers have pushed the frontier on the context windows to a pretty incredible size, so like Sonnet is at 200,000, Gemini is at a million, uh, you would be shocked at how quickly people figure out how to fill up that window. And so almost everybody using Goose in the early days before we had some of these features would just come to us and say like, "Hey, this fell apart.
I've been having this same chat running for seven days and it doesn't work anymore." Um, and so this is something that we're getting better and better at. And in some examples of revising the context, the obvious one is like when we hit up to the limit of the window, we start to summarize. So you'll see a little summarization dialogue and you can edit that summary and kind of tweak it along the way. And so that way we don't fall over when the context gets large.
Uh but we also do a lot of work on making the token usage really efficient, meaning like don't repeat content that is unnecessary. optimizing the outputs of the tool calls so that they're as small as as possible to convey the information they need to. Um, and also a lot of the times showing the human parts of the tool calls but only showing the LLM other parts. So if there's uh if you want to display like the full file, maybe you only need to show the LLM uh the diff or a small component of it.
And that all is ways that we make sure that the context window doesn't fill up too quickly. Um, which saves costs and drives performance. Okay, so with that's one loop. At that point the model has executed one tool and we show it the response from the tool and we do that indefinitely and that's what lets it solve this problem. So in that demo you saw probably like 25 tool calls as it did those two two uh human requests from me and along the way it's seeing the outputs of the previous step and then adapting and iterating on that. uh we see goose pretty pretty capable of running like multiple dozens of tool calls and handling scopes like a full endto-end PR or um you know kind of doing an entire data analysis or maybe writing a design doc and that it can do kind of in one pass as long as you give it enough information at the outset.
Uh that said um that's recent uh that happened a lot with the like evolution of the models. So in the early days that was very not true. It might be like writing just one file or making a small edit back when it was like kind of GPT40 era. But these days with like the most recent releases of the sonnet family or or Gemini 2. 5 Pro uh it's able to take on pretty big problems. Okay. So, uh, I'm going to show you some more specific examples just so you can kind of see concretely, uh, what I mean about it working for a developer use case.
11:25 Working for developers
Um, and the first one that is really fun about working on this project is that Goose will actually write itself. So, at this point, I think we're at about 70% of the lines of code in the Goose codebase were written by a previous version of Goose. Um, obviously it's still really important that there's like a human in there to pick the good lines and not just include all the lines that it's generating. Um, but this is something this is an example of a PR that we're scrolling through right now.
That was a oneshot. Um, it's a couple, it's I think it's about 2,000 lines worth of diff. Uh, and that's typical these days with the Frontier models. This is pretty easy to get it to make endto-end PRs. And uh that's obviously like really accelerating as you like building a project like this and something people use throughout the company, but also um it it gives you a way to be hands-on as you're as you're building because you're kind of working in its own codebase as you're running into errors with it and you can kind of just ask it like hey that was annoying go fix that and we'll and we'll make it iteratively better kind of every time we're working in it.
Um, some other stuff that's related and very much for engineers, uh, that come out of it being able to run a shell tool is that it can kind of administer your system, which is a little bit scary admittedly. So, when you first try this, maybe turn it into manual approval for some stuff. Uh, but in this example, we're going to a fairly complicated open- source repo that has this uh, setup guide, and we're going to ask Goose to go ahead and get that set up and running on our local machine.
All we have to do is uh kind of paste in the readme, in this case the URL on uh of the GitHub repo. Um and it'll jump right in. So the first thing it'll do here is is clone the repo and read the readme. It'll start actually like looking at the instructions. So right now you're seeing it needs to install PNPM. Uh this example is a pretty complicated stack. So there's a backend database that needs to run in Docker. there's a front end on pmppm that it has to get running on a local host port.
Um, that's all the kind of stuff that we could figure out but don't want to. Uh, in this case, for example, it found out that Docker wasn't running. Um, and it can just go ahead and open that up for us. And then, uh, once Docker is running, it's going to start the database uh, backend port. Um, I I really like this because as like an experienced developer, this is stuff I don't want to bother with. But also, I think for a more junior developer, maybe you don't know what this is.
And so, you have this readme that's got these really short commands that are telling you what to do and you could follow along, but you have no idea why. Uh, so Goose is excellent at explaining what's happening, um, if you ask. So along the way we're seeing and I think now it's actually wrapping up here. So we're going to see it does get this running on local host. Um and it gives us a little explanation of everything it did.
But if you wanted to interrupt it along the way and ask like why are you doing that? How does that work? It does excellent explanations. So this is something that I think is really powerful when you're like working with unknown software. You can kind of teach yourself as it's getting things set up. Um explain the commands and learn something new that way. Okay. And then one more flavor of this that is what everyone is talking about these days is of course you can use goose to just vibe code something.
Uh in this case I have never built an Android app. I am not a mobile developer. I wanted to just see what would happen. So I asked it to go make a to-do list app on Android. I figured out how to run the emulator so I could go interact with it. And I just start telling it what I want it to look like or what I want the features to be. Um, and I never open an editor in this example. Uh, so here it's going to convert it to dark mode and like kind of minimize the theme for me.
14:48 Using Goose to build an Android app
Um, in a second I'll start asking it for, you know, additional features like organizing things into categories. Um, what I what I like about this example is that there's a whole class of software that isn't production code. And it and it doesn't really matter if there's like awful code behind the scenes here because it's a to-do list app. like if it works, it's obvious that it's working and I don't really care um that I'm going to have to refactor it later.
I'll just do a new one when I get there. And I think you'd be shocked at how many things if you're not using AI yet, how many things you do avoid doing in your day-to-day that would just be amazing to have that have this property of like, oh, like I I made a Google doc for this, but it wouldn't been much better as an interactive website. And with something like this, you can just make the website and share it with someone throughout your organization.
Uh it works much better. And I think there's a whole class of little things where you don't even have to ask the question of like how do I handle AI code review? Um are we worried about this not being secure or production ready? Uh because it it just doesn't matter. And there's a ton of use cases like that. And I think especially for new developers and um open source developers a lot of their problems have that shape.
Okay. So one second let me talk a little bit more like I mentioned about running something like this in an enterprise context. And I mentioned at the beginning that when we use goose at block, we've got this long list of models that are available for everybody to go um use. And uh if you've ever done like admin work for your company, you know that's like a little bit scary. And you kind of want to have an approved list of models that everyone's allowed to use.
16:43 Using Goose in an enterprise context
Um and you want to have some basic telemetry. Uh so this is a place where we integrate with data bricks. And so let me actually show you what our serving endpoints page looks like on the dub bricks with all of the goose models selected. Um so we've connected about 25 of these. It's across a bunch of different backends. So in this case we've got uh you're seeing here we've got the sonnet models a bunch of open AI models.
There's a Gemini. Um that's fantastic because in this AI gateway the models don't have to be offered by data bricks. Some of them are like we're using cloud sonnet hosted on data bricks natively but we can do like admin stuff of connecting service account credentials and then getting that to operate Gemini and so for an end user that's just one um one place to go to get all the access and another thing that's really critical about this is that we have telemetry on all of these so is an open source project we don't want to collect any telemetry on the actual like oss codebase.
Um, that would be weird. People wouldn't want to see that. Uh, so instead we get it at the serving endpoint layer. So when employees are using this, we get things like how many tokens are they sending through, which gives us costs. Um, we also get which models are the most popular, how often people are using tools. Uh, that's al that's all what powered that initial demo that I showed. And so that's really powerful here.
It kind of lets us separate the agent from all of these operational concerns that we need to do. But I think probably the most important part of all of this is that we get uh no setup for our employees. So if you download goose as a block employee and you just click a button, you immediately get redirected to this like automatic login flow and you do your single sign on thing. Uh and you have access now to that whole family of models.
Um, if you've ever like tried to set that up with like a thirdparty agent, you you usually have to like create an API key and give everyone instructions for how to do that safely. Uh, and you'd like really hope that no one accidentally commits that to a repo. And so this is great for us because we kind of get that security layer. We get a lot of the telemetry we need and ultimately it just makes it easy for people to use.
Okay. I will mention though that if you are like interested in using goose, it's not only through data bricks. So if you do the open source flow, you'll like land on a page like this where you pick the provider. So if you're at a company like ours, you might start with um you know something like bedrock or data bricks. Um we also run local models a lot. So I've got Olama here. That's how we do local models. Um a lot of people care a lot about that.
So in our open source community, people will not want to send their data to any third party. They can get a completely functioning local setup. Uh which is getting better and better all the time. Like the recent QN models are pretty excellent at tool use and works well with goose and I'm pretty excited for where that's going. But also uh you know as as just a third party developer, maybe you have already have an account with OpenAI and you can connect that here.
Okay, so let me go through what I think is actually the most interesting part about using a a tool like Goose and what makes it the most different from other AI agents out there, which is that you can connect it to anything. And uh you probably have all heard about MCP, that's the model context protocol that we're using under the hood to make this work. Um that's something that was released by Antropic earlier this year. uh we were kind of an early release partner with them as we saw that we needed a problem of this shape and uh now we're on the steering committee to kind of make some contributions and help make this more secure and uh it's been extremely successful.
20:32 What makes Goose different
Um I'm sure a lot of you have like heard about it or used it and that's great for the community right because the more successful a protocol is the better it is for both sides. So that means that there's more tools available to agents like Goose. But then as a person who wants to maybe like integrate your system with AI agents, pretty much every AI agent out there these days is using MCP. So it'll work with anything.
Um so definitely like the Anthropic app, but I know OpenAI I think actually already released it. They definitely announced it that they were going to support this in their chat GBT app. So pretty much everything works with MCPD these days. So let me tell you a little bit about what that does under the hood if you haven't used it. So on the protocol um the extensions that we were showing in goose those are called MCP servers.
The MCP servers expose things like tools and resources. And so when goose runs, it starts either standard IO processes or connects um to like a remotely hosted MCP server and it can do this like kind of initial initialization handshake thing and figure out like oh these are the tools available for me to operate in those systems and uh that top one is an example of a system that we run ourselves. So the developer system is bundled with goose.
It runs on your machine. So when it's doing file editing or running shell commands, that's actually like operating your laptop. And we have several of those, including things like letting it click around your screen if you are brave enough to enable that. And there's um probably just five or six bundled natively with goose these days. I think it gets way more interesting when you go find those third parties and connect them.
So uh one of the most popular ones at Block is the Google Drive system. And we have actually our own implementation of this just to kind of drive performance, but there are several out there. Uh, and that exposes things like letting you edit docs in Google Drive directly or just reading them and kind of like that's it starts to enable flows across multiple components. Um, and of course we have things like data systems.
So in the initial demo I showed it connecting to data bricks and running queries and these uh like the really in goose the primary thing that we're getting out of the protocol are the tools. So um there's a lot to that. I'll I'll I'll not go in too much into the details. Um but I one thing I will call out is that the um extensions become the prompt for the model. So goose's system prompt when it's loaded without extensions is is only three sentences long.
So it's it's almost a blank slate until you have connected an extension. And that uh is something that we think is a good part of Goose is it's really like designed to operate any different extension. It's not a like kind of an editor that can be extended with Google Drive. It is a general purpose agent that can do any of the things that it's connected to. Um, and so really we rely a lot on the quality of the MCPS to describe what they do and how to operate them.
So the MCPS themselves comes with a description of like what it's supposed to do. The tools um the payloads kind of self-document, but the tools have descriptions and all of that is the system prompt that goose uses to actually like go figure out how to interact with them and solve problems. Okay. So uh I think for us the thing that we see as the biggest value of having something like goose is that it's uh there are so many different tools that we need to use to do our job dayto-day.
24:38 The biggest value of Goose
If you work at a tech company I'm sure you have the same thing. There's probably like 30 different SAS products that I interact with every day. Um, so for us it's like okay, we've got tickets in Jira uh that I'm going to use to like track work, but really the design is in Google Drive, so I need to read that or maybe it's in notion because a different team uses notion. Uh, I ultimately have to connect it to Git. Um, and Goose is able to sit in the middle of that and connect you between the different surfaces. uh to talk about that in a little more detail.
What I what I mean is that you can imagine that I don't know if they do actually. I don't haven't used Jira recently enough, but I would be uh very surprised if Jira doesn't soon have its own AI agent built into Jira. So you'll you'll go log into Jira and you'll click around and you'll start to see some like AI enhanced features and those are great honestly like they can make the product a lot easier to use, but the only thing that agent can do is work inside Jira.
Really what we're looking to do with Goose is workflows that cross between the different systems. So you might start in Jira, read a ticket that describes a bug you need to fix, have it go interact with your like enterprise git repo, clone it for you, and start making edits and then make a pull request. Um maybe if you're really brave, you'll connect it to your like deployment system and let it deploy to staging. Um and then hopefully you have it connected to pager duty for the inevitable fallout.
Um the uh this is like something that I think um really emerges as you connect it to more pieces because it's supposed to meet you where like you are at like it's your AI agent that connects to the tools that you use instead of being kind of locked into one small surface of what you do. Um so that really emerges and evolves over time. And uh I think there's so many examples that we could give of that specific thing. So, you know, you're an automation that we're kind of constantly trying to do is what I mentioned before with automatically fixing bugs in Jira.
But I think also it's like really normal to maybe have like a long Slack thread discussing implementation details. So, you could just have it read the thread and have that save you a bunch of writing time of like summarizing what was going on there. Um, similarly with design docs in notion or Google or whatnot. Another thing that has been really interesting for us is that we have MCPs for Square and Cash App. So those are our actual projects.
And as a person who develops against those, I have my own accounts uh both in staging and production. But in a staging environment, I might actually have Goose Go interact with something that I just deployed to staging and turn that into an integration tester. So by like connecting Goose from the code it's writing to the actual deployed product, I can go see if things are working the way I want them to and when we maybe run into an error, it just immediately has that context to go help me fix it.
U another point that I will mention about this is that so far I've really talked about Goose as a tool for developers. Um it's uh surprised us at how much adoption it's gotten from non-developers. we've we like kind of shipped it to everybody. Uh thought people would do some vibe coding which we were excited about and that did happen for sure. But um what we found was like oh like there's just a lot of useful things that you can do when you're connected to Slack and Google.
27:50 Nondeveloper adoption of Goose
Um, and so maybe our executive assistant team uses it to connect to calendar and manage like more complicated scheduling. Or as an engineering manager, maybe you're not actually writing any code, but you're working in docs and working on designs and proposals. Or as a product manager, you like manage a bunch of different Slack channels, draft up communications, and send them out um as like real documents. And so we've seen tons of different things emerge just from having it sitting in the middle of all the stuff we do. uh stuff that we didn't really plan for.
And that is uh the case we're kind of looking to lean into over time is to do more and more of like what the users are suggesting it should be able to do and less of like us trying to figure out what it needs to do up front. Okay, so let me talk a little bit about open source too. Um so far we've talked a lot about how we use goose at block which is important to us for sure. Um but uh we also have a really large open source community.
29:04 Open Source
Um and this is I think a big piece of this has been uh a couple of different bets that we think will matter for open source. But first I wanted to start with just generally at Block as a as a tech company gets a lot of value out of open source code. uh I'm sure every tech company does and we this is something we wanted to contribute back and it's a big part of our mission is to have all of our tools help enable access for people.
So something like goose gives more people access to AI agents and tooling. And it's also helps us be more open. So when we say that like one of our features is powered by goose, you know exactly what that means. And it's actually code that you can go look at yourself. But there's a bunch of other bets here that I think are important to us. Like uh we think that goose will get better ultimately because there's a like this relentless collective examination of the code and how well it's working.
We have a lot of different people who can tell us what's not do going well and we can just make it better over time. Similarly, we have a lot of uh contributors from outside a block which means that more people are building this than we could possibly source internally. I think we're we're pushing towards 10,000 contributions and the um that's I think over time our bet this is going to turn into a way to make sure that Goose is one of the top performing agents and to compete with proprietary by just having more people looking at it and contributing to it.
Um and last we work with a lot of other enterprise companies that are using Goose and kind of their view of how to get this working and their ideas on how they've gotten it to work for themselves. we can bring back to block and make things better that way. Okay, so let me finish that off with recapping why we're excited about goose. Uh first, like I just mentioned, it's open source, so please do come build it with us.
31:02 Recap
Um we uh love getting contributions from other tech companies or any developer. Uh and I think we can make it a lot better than it is today. Another is like I mentioned, goose works with any model. Uh, and this is a point that I probably didn't stress enough, but because it works with any model, that means that you can always be on the frontier of performance. And so, as you've seen in the last like several months, the models are constantly leaprogging each other because training is expensive and takes a really long time.
So, pretty much every month, we're getting a new model coming out that's better than the last. And if you're kind of locked into one model provider, you have to wait with their current best state-of-the-art. uh with something like goose you can just use whatever is working for you today. Uh we also really think that combinations of models will help unlock performance in the future. So in in the very first demo uh I showed you you in the middle of a conversation you can switch from one model to another.
That's something that we see people taking advantage of but we think we can increasingly do algorithmically so we can figure out like this is the best model for the task you're asking for and we think that'll drive performance. Uh, and then last and most importantly, you can connect Goose to everything you do. So, you can make sure that it's able to like cross between different systems and automate the parts of your job that you want it to be able to automate.
Um, or to help you solve problems that don't just sit in one particular SAS product, but span several. And that's something that we've increasingly leaned into for not just developers, but other roles at the company. Okay, so thank you. Um, this is a QR code for the GitHub repo. Uh, and excited for any follow-ups.
Learn more about the Databricks Data and AI platform.
The information provided herein is for general informational purposes only and may not reflect the most current product capabilities or configurations.