Okay, you've totally been there. You sit down, coffee's ready, and you're like, all right, this weekend I'm finally going to build that cool AI research assistant. Yeah, the dream project. Something that reads your stuff, finds the key points. Exactly. Seems simple enough. You have that initial burst of excitement. You picture this elegant agent just working. Totally. And then, you know, maybe. Four or five hours in, you're deep in some GitHub repo, and you realize
it hasn't been touched in eight months. Oh, yeah. Or the readme is just useless. Right. Or you find some blog post promising the world, but the tool it recommends. Turns out it needs five different microservices running and maybe like a PhD in YAML configuration just to get it to read a single file. The frustration is, yeah, it's definitely real. That initial energy just kind of dissolves into hours lost chasing dead ends, doesn't it? It really does. You start thinking,
is anyone actually shipping these things? Like, what are the real builders out there actually using? Not the tools that get hyped for a week and then vanish. Exactly. The ones that are, you know, reliable. The workhorses. Maybe not always glamorous, but they just... That's the core challenge right now, isn't it? Navigating that overwhelming tooling maze that the materials you shared mentioned. So much noise. A maze, all right. The goal is to cut through that. Definitely.
Right. So that's exactly our mission today. Based on this stack of source materials you provided, research papers, articles, guides, this deep dive is about giving you that curated, practical look. What emerges from this analysis as a proven open source stack for building AI agents that, well, that actually function. Think of it as maybe a real deal cheat code to skip the maze. We'll unpack the different pieces, show you what actual builders seem to be relying on based on
these sources. Yeah, because building AI agents is super exciting. The potential for them to reason, plan and act is, as the sources point out, pretty transformative. Huge potential. But the second you move from idea to implementation, it's just this flood of questions. Where do you even start? Precisely. Like if you want a voice controlled agent, what's the stack for that? Or how do you get it to handle messy scan documents?
Right. Or give it long term memory so it remembers past interactions, not just the current turn. So many questions. Exactly. Those kinds of challenges. And look. This isn't going to be an exhaustive list of every single AI tool ever created. That'd be impossible and probably outdated tomorrow. Totally. What the materials you share do is distill it down to a curated list. Tools that seem battle tested. The ones that consistently appear in projects that actually ship. The ones that provide
dependability over flash. Maybe reduce that YAML headache we talked about. Exactly. So we'll break it down by function. based on how the source materials categorize them. Think of it like the essential components of a powerful system. Each playing a specific role. Okay, let's get into it. First up, we have the agent's core logic. It's, well, it's brain, essentially. Like the frameworks. This is where you structure the agent's core process, defining its goals, its planning
loop, managing its state. It's the central nervous system that takes an LLM and turns it into something that can autonomously pursue objectives. Makes sense. So what are the key players here, according to the sources? Well, for orchestrating multi -agent collaboration, almost like building a research team with specialized roles, Crew AI gets mentioned quite a bit. So you'd have one agent searching, another analyzing, maybe another formatting the report, all working together like
a team. Yeah, that's a great way to think about it. That seems to be the sweet spot for Crew AI. Cool. What else? Another tool highlighted is Fidata. This open source toolkit is particularly focused on building assistants with persistent memory and complex tool usage. Ah, so if you wanted to build like a personalized assistant that actually remembers your preferences, your history across sessions. Fidato would be good
for that. Perfect for that kind of stateful, long -term interaction based on the description. Then, for more academic or research -oriented work in multi -agent systems and simulation, there's CAMEL. CAMEL. What's the acronym stand for again? Communicative Agent Research Lab METAL. It's really focused on exploring emergent behaviors when you have multiple agents interacting in simulated setups. Got it. More on the research
side. And what about the tools that really push the boundaries of autonomy early on, like auto -GBT? I remember that making waves. Ah, auto -GBT. Definitely a pioneer in aiming for high autonomy. The source materials describe it as trying to automate complex workflows by breaking a main goal into subtasks and executing them independently. Sounds powerful, but I remember reading it could be a bit... Unpredictable. Was
that mentioned? Yeah. The analysis you provided does mention it often requires careful prompting and oversight. It's powerful for agents needing that high degree of autonomy for multi -step objectives, but maybe not something you just let loose unsupervised on critical tasks. Right. Makes sense. Need some guardrails. Then there's Autogen from Microsoft Research. This framework focuses on multiple agents having conversations with each other to collaboratively solve complex
tasks. Like the problem is too big for one agent, so they kind of talk it out and figure out a solution together. Exactly. That's the model. For a more developer -first approach, aiming for a streamlined path to building and managing autonomous agents, Super AGI is highlighted. Okay, so focused on getting something deployed faster. That seems to be the goal, yeah, providing
a quicker path to shipping. And for a more modular approach, where you want flexible building blocks for highly custom solutions, SuperAgent is mentioned as a toolkit providing those components. Kind of like Lego bricks for building agents. Sort of, yeah. More flexibility if you need a really custom setup. And then we have the foundational libraries, the ones that often act as the plumbing or engine underneath a lot of these higher level frameworks, right? Langchain and LAMY index.
Absolutely critical. Langchain is described in the materials as that comprehensive framework for building LLM applications generally. Handles things like chaining calls, managing memory, integrating tools. It's foundational. A real Swiss army knife. Kind of, yeah. And LAMY index is equally key, specifically for data indexing and retrieval. essential for connecting LLMs to your own custom data sources, documents, databases. That's the basis for RAG, retrieval augmented
generation, right? Exactly. Letting your agent actually read and understand your company's internal reports or a stack of research papers for that research assistant we talked about earlier. Yeah, that's huge. So, line chain and LAMA index are really the go -to for managing memory, doing RAG, building tool chains, and often they underpin these other frameworks. That's definitely the picture painted by the sources. They're often
working behind the scenes. Okay. So, that gets the agent's core thinking process structured. But an agent needs to interact with the world, right? It can't just think. Exactly. It needs hands and eyes, computer and browser use. Right. Giving your agent the ability to actually interact with the operating system and the web, just like a human would, clicking, typing, scrolling, scraping information, running scripts. Bridging the gap between its thought process and taking action
in the digital world. So what's the tool that lets it run code and interact with files directly on your machine? I think I saw that mentioned.
that would be open interpreter the source materials describe it as letting llms run code prathon javascript shell scripts directly from natural language commands so you could tell that things like find all pdf files in this folder and count the pages and it just does it yeah it handles generating and executing the necessary code locally Super powerful for automating tasks directly on your computer, local file operations, system interaction. Wow, okay. That opens up a lot of
possibilities. Very much so. Then the analysis you shared touches on more advanced concepts, like self -operating computer frameworks. These are described more as research projects aiming for full desktop control. Like the agent literally seeing your screen, controlling the mouse and keyboard on Windows, macOS, or Linux. That's the ambition. So it could potentially automate tasks across, like, Photoshop, a web browser, and a spreadsheet application, all interacting
visually. That sounds complicated. It is. The source materials note this is still an active area of R &D with varying levels of stability. Think cutting -edge research for now. Gotcha. So maybe not for your first agent project. Probably not. Related to this are frameworks like Agent S and other UI automation frameworks. They allow agents to use existing UI applications by interpreting visual information directly from the screen.
Ah, okay. So if an app doesn't have a clean API, the agent can still use it by seeing and clicking elements, like a human would. Precisely. It's visual interaction. Then, specifically for building web agents, there's LeVague. LeVague. What's its focus? It's highlighted for its focus on letting LLMs navigate websites, understand the structure, fill forms, and click buttons based on natural language instructions. Think automating
complex web scraping or online data entry. Okay, so specifically designed for web tasks using LLMs understanding. Right. And underneath that, or maybe used alongside it, there are the foundational browser automation libraries that a tool like LeVague might use. The heavy lifters for browser stuff. Yes, absolutely essential are Playwright from Microsoft and Puppeteer from Google. Playwright is described as a powerful library supporting all major browsers, Chromium, Firefox, WebKit,
known for reliable scripting. Good for testing and scraping. Yeah, great for end -to -end web testing, simulating user flows, and reliable web scraping. Puppeteer is a hugely popular Node .js library specifically for Chrome and Chromium automation. Also great for scraping dynamic sites, front -end testing, or generating PDFs. So if your agent needs to reliably and deeply interact with the web, filling out forms, clicking things, extracting data, these two libraries are kind
of the bedrock. Playwright and puppeteer. Exactly. They're often the underlying engines providing that robust web interaction capability. You'll see them use it everywhere for web automation. Okay. Brain, hands, eyes. Check. What about giving our AI agent a mountain ears? Voice capabilities seem pretty key for lots of applications. Crucial
for natural conversation. Yeah. This category, according to the sources, breaks down into understanding spoken language, speech to text, or STT, and responding naturally, text to speech, or TTS. Makes sense. How do the materials group the tools? Well, for handling the entire voice conversation loop in real time, you've got a few options mentioned. Handling both sides of the call, back and forth.
Low latency would be key there. Totally. Ultravox is mentioned as a top tier model focusing specifically on speed and responsiveness. The sources note this makes it ideal for live interactive agents where that low latency is critical. OK, for real time chat. Moshi is described as another strong option, valued for reliability specifically in live interaction scenarios. Good for conversational AI or voice controlled apps where stability is paramount. So maybe less bleeding edge speed,
more reliability. That's kind of the impression. And then Pipecat is presented as a full stack framework explicitly for building voice agents. It aims to handle the entire pipeline. Pipeline meaning STT, LLM, TTS, all integrated. Yeah, exactly. And the source is even... hint at future video integration so it sounds more comprehensive for like building a complex voice bot or virtual assistant from the ground up. Okay, like an end
-to -end solution. Interesting. Then just for the STT part, just converting speech to text whisper from OpenAI is highly acclaimed. Heard a lot about whisper. Yeah, the source analysis emphasizes its exceptional accuracy, multilingual capabilities, and robustness, even with accents and background noise. It seems like the go -to for transcribing voice commands, meetings, or any voice input. So industry standard, almost. Pretty much seems that way from the materials.
And StableTees, I saw that mentioned alongside Whisper. Ah, yes. StableTees presented as a developer -friendly wrapper around Whisper. It adds useful features like word -level timestamps and improved real -time support. Okay, so... Handy if your voice chatbot needs precise timing or you need to generate accurate subtitles from agent output. Exactly those kinds of use cases. And for analyzing audio with multiple speakers, like figuring out who spoke when, the sources mentioned speaker
diarization 3 .1 from Pianote .audio. Ah, okay. So if you're analyzing, say, customer calls or meetings to understand the interaction flow between different people, that's super useful. Definitely. What about the other direction, giving the agent a voice to respond, TTS? Right, text -to -speech. ChatTS is highlighted as a strong open -source model for converting text to natural speech. It's described as fast, stable, and production -ready. Good for spoken responses, maybe audio
versions of documents. Yeah, those kinds of applications. The source materials also reference commercial options like Eleven Labs and Cartesia as benchmarks for quality. So not open source, but mentioned as the gold standard for naturalness. That's the context. They're cited for exceptional, highly human -like or expressive voice quality if a commercial solution is something you'd consider for top -tier naturalness. Maybe for premium
voice assistants or audiobooks. Gotcha. So open source options like ChatTS are solid and production ready, but those commercial ones are still maybe the cutting edge for pure voice quality. That's the implication from the comparison in the sources, yeah. And then there are miscellaneous tools grouped together like Vocode. What's Vocode? It's presented as a toolkit specifically for building voice -powered LLM agents, simplifying the connection between STT, the LLM, and TTS.
Seems great for rapid prototyping of voice -first applications. Sort of gluing the pieces together more easily. Looks like it. And VoiceLab. Which seems to be less a single tool and more a category or framework concept for systematically testing voice agents. Wait, testing voice agents? How do you test a voice? What does the source say?
The analysis indicates it's crucial for dialing in performance testing STT accuracy under different noise conditions, evaluating the naturalness of the TTS output across various phrases, simulating conversational flow with turns and interruptions. To make sure the agent handles them gracefully. Exactly. It's about creating structured audio test cases to catch potential breakdowns early, before users encounter them, ensuring the voice experience is actually good. Okay, that makes
a lot of sense. So we've got the agent thinking, acting in the digital world, and talking. What about reading, especially dealing with messy formats like PDFs or scans that aren't just plain text? That's a huge challenge. Document understanding, huge area. Giving your agent the ability to read, interpret, and extract data from complex and unstructured formats. The source materials heavily feature vision language models here. VLMs, models that understand both images and text together.
Exactly. Quen2VL from Alibaba. is highlighted as a particularly powerful VLM for this task. The analysis suggests it's exceptional specifically on complex documents. Like what kinds of documents? Things like invoices, scanned forms, or scientific papers that mix text with graphs and tables. It seems to perform well on layouts that confuse simpler OCR -only models. So it can handle those tricky visual elements and still extract the right information. Yeah, that's impressive. That's
the reported strength, yeah. And then there's .cowl2. described as a lightweight multimodal model focused on document understanding without relying solely on traditional OCR. Without OCR, how does that work? Does the source explain the mechanism? The analysis doesn't go into deep technical detail on the how, but it implies it processes the document more holistically. Maybe looking at layout and visual features alongside text -like tokens rather than just recognizing
characters first. Interesting. And the benefit? The benefit highlighted is it can be faster and more efficient, especially for unusual layouts or documents that traditional OCR struggles with, like maybe flyers or image -heavy forms. Fascinating. So reading the unreadable, messy stuff more effectively, that's a critical piece for many business applications. Totally. Now, to make the agent more than just like a single turn assistant, it needs... Well,
it needs memory. Absolutely essential for continuity and context, giving it both short -term conversational memory and long -term recall so agents can learn from interactions, remember past info, build context. Otherwise, it's like talking to someone with amnesia every few seconds. Exactly. What tools are specifically dedicated to memory in this stack, according to the sources? Memdero is highlighted as an open -source project describing itself as a self -improving memory layer. Self
-improving memory, what does that mean? The idea here, according to the materials, is memory that doesn't just store facts, but allows agents to adapt their behavior based on past feedback or outcomes. Oh, wow. Like personalized tutors or service agents that actually get better the more you interact with them. That seems to be the concept. A key piece for more sophisticated, adaptive agents. Very cool. What else for memory? Then there's letter, formerly known as MemGPT.
This tool is specifically focused on managing long -term memory and navigating the limitations of LLM context windows. Ah, dealing with that limited context window is a big problem. Right. Letta provides a scaffolding layer that allows agents to retain information from hundreds of documents or maintain coherent, continuous conversations over long periods, something standard LLMs really
struggle with on their own. Okay, so... Designed specifically to scale memory way beyond just the current chat history or a few past turns. That's the focus. And of course, Langchain, mentioned earlier as a framework, also has built -in plug -and -play memory components. Right, it has modules for that. Yeah, basic conversational history, integrating with vector stores for document memory,
which ties back to RRAG and Lamed Index. If you're already using Langchain, its memory modules are a straightforward way to start adding this capability. Makes total sense. Okay, building these agents is one thing, but how do you make sure they actually work reliably in the real world? That needs rigorous testing, right? Absolutely non -negotiable, according to the materials. Rigorously testing agent behavior, catching bugs early, ensuring they don't break
down unexpectedly when users rely on them. So what tools help with that? The sources actually re -mentioned VoiceLab here, didn't they? They did, yeah, but specifically in the context of testing frameworks for voice agents, as we discussed earlier. Ah, right. Not just the underlying voice tech, but the process of systematically testing voice performance. Exactly. Why it's crucial.
STT accuracy under noise, evaluating TTS naturalness, simulating full conversational flows with interruptions or edge cases, building those structured audio test cases. Okay, so a framework to systematically evaluate voice performance is critical. What other testing tools are highlighted in the analysis? Agent Office is mentioned again. The source analysis describes it as a suite for tracking, benchmarking, and operating agents. How does it fit into testing
specifically? Why it's crucial for testing. It gives you that holistic view of performance metrics during testing runs. Helps you compare different versions of your agent, different prompts, and spot where things break down before you deploy. So it kind of bridges testing and monitoring. Helps during development? It seems to span both, yeah. Useful for benchmarking during development and testing, and then monitoring after deployment. For dedicated benchmarking before deployment,
though, there's also AgentBench. AgentBench. What does that do specifically? It's described as an open -source standardized benchmark tool for evaluating LLM agents across a diverse set of tasks and environments. Like what kind of tasks? Things like web browsing, information retrieval, interacting with simulated software. It gives you a way to get a more objective score on how versatile and effective your agent is
at common real -world challenges. Okay, so it helps evaluate new LLMs within your agent or test different architectures against known benchmarks. Identify weaknesses early. Precisely. The source analysis really emphasizes that robust testing and evaluation tools like these are absolutely critical for building agents you can actually trust. Which naturally leads us into keeping an eye on them once they're live. Yeah. Monitoring and observability. Can't just deploy and forget.
Definitely not. Key for understanding what your agents are doing in production, how well they're performing, spotting errors in real time, and tracking resource use, especially costs. What's highlighted for monitoring in the sources? Open elementary comes up. It's an initiative or set of practices built on the well -known open telemetry standard, but tailored for AI. Tailored how? The materials describe it as providing end -to -end observability specifically for LLM applications
and agents. It tracks AI -specific metrics like prompt response details, token usage, latency, and task success or failure rates. So not just generic server logs, but visibility into the AI behavior itself. Like, why did it give that weird response? Exactly. It's for performance monitoring, finding bottlenecks, cost management by tracking token consumption, debugging production errors with detailed logs and traces, and getting
usage analytics. You integrate libraries into your agent code to emit this kind of telemetry data. That sounds essential for managing costs and performance at scale. And AgentOps, again, here in the monitoring section. Yes, re -mentioned because it also serves as a platform specifically for monitoring deployed agents. It provides dashboards and features. for those operational aspects.
So it offers a more ready -made solution. Yeah, you can set alerts for things like error rates or increased latency, compare the cost effectiveness of different LLMs in production, get KPIs on agent performance. It might offer a more out -of -the -box monitoring solution compared to setting up a full custom open telemetry pipeline,
depending on your needs and team. Okay, so testing helps you refine before deployment, catching issues, and monitoring helps you ensure reliability, efficiency, and cost effectiveness after they're live and interacting with users or data. That's exactly the distinction the materials draw. Both are crucial for building reliable agents that you can operate effectively. Makes sense. What about practicing, like letting agents learn and interact in safe environments before you unleash
them on the real world or sensitive data? Simulation environments. The analysis you shared calls these safe playgrounds absolutely critical for... testing and refining complex autonomous agents in controlled settings without real -world consequences. Okay, what tools or concepts are important here, according to the sources? Agentverse is highlighted as a platform specifically for deploying and interacting
with multiple agents in simulations. The focus is on creating detailed settings for agents to coexist and studying their emergent behaviors. So you could simulate interactions in a customer service department or an e -commerce site. See how agents collaborate or compete. Exactly. Like a little miniature world you build for your agents to live and interact in. You define the environment and rules and see what happens. Sounds cool.
What else? Then there's TauBench, described as a benchmarking tool specifically focused on evaluating an agent's ability to use tools and complete tasks, often in specific industry contexts. Like retail or airlines. Yeah, testing an agent's ability to correctly use a simulated API to book a flight or handle a retail checkout process within that safe simulated environment. It's a structured way to assess domain -specific tool
use. Got it. And Chatterina. That's another mentioned tool described as a multi -agent language game environment. Agents interact with each other, often in game -like scenarios or debates. So, more focused on studying how agents communicate, negotiate, or refine their conversational patterns through interaction. That seems to be the goal. The materials also mention a foundational concept that inspired much of this work, the Generative Agents Research Project from Stanford. Remember
that paper? Less a tool, more the blueprint. Exactly. The architecture idea for creating human -like agents with memory, reflection, and planning capabilities, sort of the theoretical basis for believable simulated agents. And then there's a more practical implementation inspired by that concept, something you can actually use. Right. AI Town. It's presented as a deployable, customizable starter kit for creating a virtual town environment
based on those generative agents' ideas. It lets you quickly set up a simulated social world. Oh, cool. So you could fine -tune an agent's social behavior or decision -making by testing it against other simulated agents in that AI -down environment. Connects the theory to a practical sandbox. It really does. Simulation environments provide that invaluable low -risk space for experimentation, training, and refinement before real -world deployment, especially for complex, autonomous behaviors.
Okay, wow. We've covered a whole stack of building blocks. Frameworks, interaction, voice, reading.
memory testing monitoring simulation but sometimes you don't need to build every single thing from scratch right yeah the sources mentioned pre -built solutions absolutely vertical agents using pre -built ai systems designed for specific problems or domains the materials know you can use them standalone or integrate them into your larger agent architecture as a specialized component okay so what categories did the sources highlight Like for coding, that seems like a prime area.
Definitely. Plenty mentioned here. Open Hands is highlighted as a platform for software development agents focused on automating coding tasks. Okay, like a dedicated coding assistant? platform? ADER is described as a command line AI pair programmer that integrates directly with your terminal and Git. You literally chat with it in your shell to edit code files. That's super practical. Chatting with an AI assistant right inside your existing coding workflow. That sounds useful. Right. Seems
very dev friendly. Then GPT Engineer aims to build entire applications from natural language prompts. You tell it what you want. It asks clarifying questions and generates a basic code based scaffold quickly. Like bootstrapping a project from an idea. That's the idea. And Screenshot to Code is pretty neat. It does exactly what it sounds like. Converts a screenshot of a website or UI design into front -end code, like HTML, Tailwind, React, Vue. Wow, turning visuals directly into
editable code? That could save a massive amount of time, especially for front -end prototyping. Huge potential for accelerating that initial build phase. Then, for research and information synthesis, the materials mention GPT Researcher. What's its focus? It's presented as an autonomous ager designed to conduct comprehensive research on a topic, breaking down questions, searching the web, analyzing sources, and compiling a structured
report. So streamlining that whole painful process of gathering and synthesizing information across potentially dozens of sources. Yes, please. Definitely a productivity booster for research tasks. And finally, for interacting with SQL databases using natural language, Vana was highlighted. Vana. How does that work? It's a Python based AI SQL agent. You train it on your database schema and then non -technical users can ask questions in plain English. It generates and runs the SQL
query needed to get the results. Okay, so effectively democratizing data access. People who don't know SQL can just ask the database questions like they're talking to an assistant. That seems to be the goal, yeah. Making data more accessible within an organization. These vertical agents show you don't always have to build every capability from fundamental blocks. Sometimes a specialized, pre -trained agent is the right tool for a specific part of your overall system. Okay, that makes
a ton of sense. So looking back at that initial struggle we talked about, the frustration of the tooling maze, the outdated repos, the YAML nightmares. That maze is definitely a real barrier for a builder starting out. It's easy to get lost. But the core lesson from the analysis you shared, it feels like it's not about finding one magic perfect tool or constantly chasing the bleeding edge or the latest hype, right?
Not at all. The materials consistently point towards sticking to what genuinely works, prioritizing simplicity where possible, reliability, and embracing a pragmatic, well -chosen open source stack. It's like the early struggles kind of teach you that the agents that actually get deployed aren't built with smoke and mirrors. Exactly. They're built with dependable components, carefully chosen across these key functions we discussed, framework,
interaction, memory, testing, and so on. So successful open source agent development isn't necessarily about reinventing the wheel for every single part. It's more about choosing the right tools from this growing ecosystem. Integrating them thoughtfully, making sure they work together. And then relentlessly testing and refining based
on how they actually perform. Yeah, whether your goal is automating workflows, building voice assistants, creating systems that understand complex documents, running simulations, or enabling non -technical users to query data. Using a well -chosen integrated open source stack just makes the whole process smoother. More efficient, definitely more transparent since it's open source, and often more cost effective in the long run compared to maybe some proprietary black boxes. That's
often the case, yeah. The analysis says it really well. This ecosystem is vibrant. The future is being built with these blocks. And based on these materials, you really do have everything you need to be a part of building it. The tools are there. You just need to navigate the maze effectively. Yeah, pick a category that resonates with the problem you're trying to solve. Explore one of the tools we mentioned in that area. Maybe Crew AI for collaboration, or Open Interpreter for
local tasks, or Quen2VL for documents. Experiment. Tinker. Just get started with something reliable from this kind of curated list, rather than grabbing the first shiny thing you see on social media. Don't get lost in the hype maze. Pick a solid path and start building. Exactly. That feels like a really solid place to wrap up this deep
dive. Hopefully this gives you, the listener, a much clearer picture of the landscape and some concrete places to start building, maybe bypassing some of that initial tooling chaos we all face. A curated look at the dependable tools that actual builders seem to be relying on, derived directly from the materials you shared with us, focusing on what works. Right. Thank you for joining us for this deep dive into the proven open source
AI agent stack. From the core frameworks in memory to giving agents the capability to interact, understand documents, talk, and learn in simulations. The tools are out there, they're maturing, and they're ready to be put to work. Explore them, experiment with them, and see what kind of powerful agents you can build. to automate workflows, create amazing assistants, or tackle complex data challenges. The possibilities really are pretty vast, and the barrier to entry is getting
lower thanks to these open source tools. They absolutely are. Lots to build. We'll catch you on the next one.