Open Source Agentic AI Frameworks: The Agent Uprising Exp...
What is an Open Source Agentic AI Framework?
An open source agentic AI framework is a software architecture that enables large language models (LLMs) to operate as autonomous agents, performing complex tasks by breaking them down, planning actions, and interacting with tools and environments.
These frameworks extend the capabilities of LLMs beyond simple text generation, allowing them to engage in multi-step problem-solving, decision-making, and dynamic adaptation. By providing crucial components such as planning modules, memory systems, tool-use interfaces, and communication protocols, they transform static models into proactive entities capable of achieving defined goals.
The open-source nature of these frameworks fosters rapid innovation, community collaboration, and transparent development, making agentic AI accessible to a broader range of developers and researchers. This collaborative environment accelerates the evolution of agent capabilities and promotes the integration of AI agents into diverse applications.
Open source agentic AI frameworks are essential for evolving LLMs from mere language generators into sophisticated, goal-oriented autonomous systems capable of complex interactions and multi-step task execution.
Why Are Agentic AI Frameworks Crucial for LLMs?
Agentic AI frameworks are crucial for LLMs because they equip these powerful models with the necessary "hands and feet" to interact with the real world and accomplish complex, multi-faceted objectives. Without such frameworks, LLMs are limited to generating text based on prompts, lacking the ability to plan, execute, or adapt dynamically.
These frameworks provide the scaffolding that transforms an LLM from a passive knowledge base into an active problem-solver. They introduce elements like explicit goals, memory for maintaining conversational state and past actions, planning algorithms to break down tasks, and the ability to use external tools or APIs.
This integration of agency enables LLMs to automate workflows, manage projects, perform research, and even contribute to software development by intelligently orchestrating various computational resources and data sources. The true potential of LLMs is unlocked when they can act purposefully.
How Do Open Source Frameworks Differ from Proprietary Solutions?
Open source agentic AI frameworks primarily differ from proprietary solutions in their accessibility, transparency, and community-driven development model. Unlike closed-source alternatives that maintain their code and algorithms under wraps, open source agentic AI framework projects make their entire codebase publicly available.
This transparency allows developers to inspect, modify, and extend the framework's capabilities without licensing restrictions, fostering greater innovation and customization. The community aspect means that development often benefits from a diverse group of contributors who collaboratively identify bugs, propose new features, and share best practices.
Proprietary solutions, conversely, often offer polished products with dedicated support but limit user control and transparency, potentially leading to vendor lock-in and slower adaptation to specific or niche use cases. Open source provides unparalleled flexibility and control over the underlying AI infrastructure.
What Are the Core Components of an Agentic AI Framework?
The core components of an agentic AI framework typically include a planning module, a memory system, tool-use capabilities, and an execution environment, all orchestrated to enable autonomous action from an LLM.
These elements work in concert, allowing an agent to receive a high-level goal, conceptualize a series of steps to achieve it, remember past interactions and outcomes, and leverage external utilities to perform specific operations. Effective integration of these components is vital for robust agent behavior.
Each component plays a critical role in the agent's lifecycle, from understanding the initial prompt to successfully completing complex multi-step tasks. Mastering these components is key to building sophisticated agent systems.
How Does the Planning Module Function in Agent Architectures?
The planning module in agent architectures is responsible for taking a high-level goal and breaking it down into a sequence of actionable steps, often leveraging the LLM's reasoning capabilities to generate a strategic roadmap. This module acts as the "brain" of the agent, devising a plan to achieve its objectives.
It can employ various strategies, from simple chain-of-thought prompting to more sophisticated tree-of-thought or graph-based planning algorithms, to determine the most efficient and effective path. The quality of a planning module directly impacts the agent's ability to solve complex, novel problems.
This planning process is often iterative, allowing the agent to refine its steps based on observed outcomes during execution, demonstrating a form of self-correction. The planning module's output guides the agent's subsequent actions and tool selections.
What Role Does Memory Play in Agentic Systems?
Memory plays a crucial role in agentic systems by allowing agents to retain information about past interactions, observations, and decisions, providing context for future actions and enabling long-term goal pursuit. Without effective memory, agents would operate reactively, losing coherence across multiple steps.
Agent memory systems often comprise short-term memory (like a scratchpad for current task details) and long-term memory (vector databases for storing and retrieving relevant past experiences or learned knowledge). This hierarchical approach ensures that agents can access both immediate context and deeper insights.
The ability to recall and appropriately utilize past information is fundamental for agents to learn, adapt, and maintain consistent behavior over extended periods, making them more sophisticated than stateless LLM calls. Effective memory management is a cornerstone of intelligent agent design.
How Do Agents Utilize External Tools and APIs?
Agents utilize external tools and APIs by selectively invoking them to perform specific functions that LLMs themselves cannot execute, such as searching the internet, running code, accessing databases, or interacting with software applications. This capability is often dubbed "tool-use" or "function calling."
The agent's planning module decides which tool is most appropriate for a given sub-task, formulates the correct input parameters, and then interprets the output from the tool to further its goal. This enables agents to bridge the gap between their linguistic reasoning and real-world actions.
Leveraging tools significantly expands the agent's operational scope, allowing it to gather up-to-date information, perform computations, manipulate data, and communicate with other systems, making it a powerful orchestrator of digital resources. This interactivity is key to practical agent applications.
When designing tool interfaces for your agent, ensure clear function descriptions and robust input validation. This minimizes "hallucinations" where the LLM might misuse tools due to ambiguous instructions, making your agent more reliable.
How Do Open-Source Frameworks Like CrewAI and AutoGen Enable Multi-Agent Systems?
Open-source frameworks like CrewAI and AutoGen enable multi-agent systems by providing structured environments and communication protocols that facilitate collaboration among multiple AI agents, each specializing in distinct roles or tasks. These frameworks move beyond single-agent operations to distributed intelligence.
They allow developers to define teams of agents, assign them specific responsibilities, and set up mechanisms for agents to exchange information, delegate tasks, and collectively work towards a shared objective. This mirrors human team dynamics, enhancing complex problem-solving capabilities.
By orchestrating interactions between specialized agents, these frameworks overcome the limitations of individual LLMs, allowing for more robust, scalable, and sophisticated solutions for intricate real-world challenges. The synergy created by multi-agent collaboration is a significant leap forward.
What is CrewAI and How Does It Facilitate Agent Collaboration?
CrewAI is an open source agentic AI framework designed specifically for building multi-agent systems that emphasize collaborative task execution and role-playing among intelligent agents. It provides a intuitive structure for defining crews of agents, each with specific skills, tools, and goals.
In CrewAI, you define agents with specific roles (e.g., "Researcher," "Writer," "Editor"), assign them relevant tools, and then create a "crew" with a shared main goal. The agents then communicate and collaborate, often using predefined hierarchical or sequential workflows, to achieve this goal.
This framework is particularly well-suited for scenarios requiring structured teamwork, where tasks can be broken down and assigned to specialists, such as content creation pipelines, research projects, or complex analytical workflows. CrewAI simplifies the orchestration of these collaborative processes effectively.
CrewAI's strength lies in its explicit role-based agent design and structured collaboration capabilities, making it ideal for automating complex workflows that benefit from a division of labor among specialized AI entities.
What is AutoGen and How Does It Support Conversational Agents?
AutoGen is an open-source framework developed by Microsoft that enables the creation of multi-agent conversations where agents can communicate with each other and with humans to solve tasks, supporting highly flexible and dynamic interactions. It emphasizes conversational programming as a paradigm.
AutoGen allows developers to define various agents, including assistant agents, user proxy agents (representing human users), and tool agents, each with distinct capabilities. These agents engage in multi-turn conversations, iteratively exchanging messages and code, to collectively arrive at a solution.
Its strength lies in its flexibility for defining complex interaction patterns and its ability to seamlessly integrate human feedback into the agent conversation loop. AutoGen facilitates robust solutions for tasks ranging from code generation and debugging to interactive data analysis through collaborative dialogue.
How Do These Frameworks Benchmark Performance on Real-World Tasks?
Open-source agentic frameworks like CrewAI and AutoGen benchmark performance on real-world tasks by evaluating their ability to successfully complete complex, multi-step objectives that require planning, tool use, and often, collaboration. Benchmarking goes beyond simple LLM metrics.
Key metrics include task completion rate, efficiency (time or computational resources consumed), solution quality (e.g., accuracy of generated code, relevance of research summaries), and robustness to varying inputs or unexpected scenarios. Frameworks are tested on diverse domains like software development, data analysis, and content generation.
These benchmarks often involve objective evaluation criteria, sometimes requiring human assessment for qualitative aspects, to provide a comprehensive understanding of each framework's strengths and weaknesses in practical applications. The goal is to move towards autonomous problem-solving efficacy.
Ready to Build Your First Agent?
Dive into the world of autonomous AI systems with our comprehensive guide to open-source frameworks. Learn to equip LLMs with the ability to plan, act, and achieve complex goals.
Explore Agentic AI βWhat Architectural Patterns Underpin Effective Agentic Frameworks?
Effective agentic frameworks are underpinned by architectural patterns such as the ReAct (Reasoning and Acting) paradigm, planning and execution loops, and modular tool integration, all designed to imbue LLMs with greater autonomy and capability. These patterns provide the structural blueprint for intelligent behavior.
The ReAct pattern, for instance, combines reasoning steps (thinking about the problem) with action steps (executing specific tools) in an interleaved fashion, allowing for dynamic adaptation. Planning and execution loops ensure that agents continually refine their approach based on observed outcomes.
Modular tool integration ensures that the agent can easily connect to and utilize a diverse set of external resources without tight coupling to specific implementations. These patterns collectively enable agents to achieve complex goals through systematic and adaptable approaches.
How Does the ReAct Pattern Enhance Agent Capabilities?
The ReAct (Reasoning and Acting) pattern significantly enhances agent capabilities by allowing LLMs to interleave reasoning traces with actions, enabling more robust planning, dynamic task execution, and improved error handling. This approach contrasts with purely sequential thought processes.
Instead of just generating a plan and then executing it blindly, an agent following ReAct will reason about the task, decide on an action (e.g., use a search tool), observe the result of that action, and then reason again about the next step based on the new information. This iterative process allows for self-correction.
This dynamic interaction between thought and action makes agents more adaptable, reduces hallucination by grounding decisions in tool outputs, and improves their ability to navigate complex, uncertain environments. ReAct is a fundamental building block for highly capable agents.
What is the Significance of Planning and Execution Loops?
Planning and execution loops are significant because they provide agentic frameworks with a robust mechanism for sustained, goal-oriented behavior, allowing agents to iteratively refine their actions and adapt to changing conditions. This loop is the engine of an agent's self-improvement and progress.
Within this loop, an agent first formulates a plan, which might be a series of steps or a complex decision tree. It then attempts to execute the first step of that plan, observes the outcome, and evaluates whether the plan is still valid or needs adjustment.
If execution deviates from expectations or new information emerges, the agent can re-plan or adjust its current trajectory, ensuring resilience and adaptability in dynamic environments. This continuous feedback mechanism is critical for complex, long-running tasks.
Why is Modular Tool Integration Key to Scalable Agent Systems?
Modular tool integration is key to scalable agent systems because it allows agents to easily incorporate new functionalities and interact with diverse external services without requiring significant changes to the agent's core logic. This promotes flexibility and extensibility.
By designing tool interfaces that are standardized and independent of the agent's internal workings, developers can rapidly add capabilities like web scraping, database querying, image generation, or API interactions as needed. Each tool serves as a discrete, reusable module.
This modularity not only simplifies development and maintenance but also enables agents to tackle an ever-expanding array of tasks, making them highly versatile and future-proof. A rich ecosystem of tools directly translates to more powerful and general-purpose agents.
What are the Challenges and Limitations of Open Source Agentic AI Frameworks?
Despite their rapid advancements, open source agentic AI frameworks face challenges and limitations, including issues with reliability, computational costs, ethical considerations, and the complexity of managing multi-agent interactions. These hurdles demand ongoing research and development.
Reliability can be a concern as agents can sometimes "hallucinate" incorrect tool use or generate suboptimal plans, leading to inconsistent performance. The iterative nature of agents can also lead to higher API call costs compared to single-shot LLM prompts.
Moreover, ethical dilemmas surrounding autonomous decision-making and potential misuse, along with the inherent complexity of debugging and orchestrating multiple interacting agents, present significant obstacles to widespread adoption and deployment. Addressing these limitations is paramount for the future of agentic AI.
How Do Reliability and Hallucination Impact Agent Performance?
Reliability and hallucination significantly impact agent performance by leading to unpredictable or incorrect outcomes, undermining user trust and limiting the agent's effectiveness in critical applications. An agent's utility is directly tied to its consistent and accurate operation.
Hallucination, where the LLM generates plausible but factually incorrect information or imagines non-existent tools/APIs, can cause agents to take inappropriate actions or produce flawed results. This is particularly problematic when agents interact with real-world systems.
Ensuring reliability requires robust planning mechanisms, effective tool validation, and often, human oversight or verification at critical junctures. Mitigating hallucination is an active area of research, focusing on grounding techniques and more sophisticated reasoning paradigms within the open source agentic AI framework.
Always implement guardrails and human-in-the-loop mechanisms for agent systems operating in sensitive domains. Full autonomy without robust validation can lead to unintended consequences, especially when interacting with external APIs or mission-critical data.
What are the Computational and Cost Considerations for Running Agents?
The computational and cost considerations for running agents can be substantial, primarily due to the iterative nature of their operations, which often involves multiple LLM calls and tool executions for a single task. This differs from simpler LLM interactions.
Each planning step, reasoning phase, tool invocation, and observation processing often translates to a separate API call to an LLM provider, accumulating costs quickly, especially with complex or long-running tasks. Furthermore, managing the state and memory for multiple agents requires significant computational resources.
Optimizing agent prompts, caching responses, and strategically choosing smaller, more efficient LLMs for certain sub-tasks are strategies employed to manage these costs. The infrastructure required to deploy and scale multi-agent systems also adds to the overall computational overhead.
How Do Ethical Concerns Manifest in Autonomous Agent Systems?
Ethical concerns manifest in autonomous agent systems through issues like bias amplification, lack of accountability, misuse potential, and the challenges of ensuring fairness and transparency in decision-making. As agents gain more autonomy, these concerns become more pressing.
Agents, inheriting biases from their training data or developers, can perpetuate or even amplify unfair outcomes, ranging from discriminatory recommendations to biased resource allocation. The "black box" nature of some LLM-driven decisions makes it difficult to pinpoint accountability when errors occur.
The potential for agents to be used for malicious purposes, such as generating propaganda at scale or executing automated cyberattacks, raises serious ethical alarm bells. Robust ethical guidelines, explainability features, and rigorous testing are essential to mitigate these risks when developing any open source agentic AI framework.
Practical Guide: How to Use an Open Source Agentic AI Framework (e.g., CrewAI)
This section provides a practical guide on how to get started with an open-source agentic AI framework, specifically using CrewAI as an illustrative example. We will walk through setting up a project, defining agents, creating a crew, and running a collaborative task.
While the exact syntax and features may vary between frameworks like AutoGen or LangChain Agents, the underlying principles of defining roles, goals, and communication patterns remain consistent. This guide aims to provide a foundational understanding for building your first multi-agent system.
We'll focus on setting up a simple content creation workflow, demonstrating how different agents can collaborate to research, write, and refine an article, showcasing the power of agentic collaboration in a practical scenario.
Set Up Your Development Environment and Install CrewAI
Before you begin, ensure you have Python 3.9 or newer installed on your system. Open your terminal or command prompt and create a new virtual environment to manage dependencies. This isolates your project from other Python installations. Navigate to your desired project directory and execute python -m venv agent_env to create the environment, then activate it using source agent_env/bin/activate (on Linux/macOS) or agent_env\Scripts\activate (on Windows).
Once the environment is active, install CrewAI using pip: pip install crewai crewai_tools. You'll also need a large language model. For this guide, we'll assume you're using OpenAI's models (e.g., GPT-4), so install the OpenAI library: pip install openai. Finally, establish your OpenAI API key as an environment variable: export OPENAI_API_KEY='your_openai_api_key_here' (replace with your actual key).
Define Your Agents: Roles, Goals, and Tools
In CrewAI, you define individual agents with specific roles, personal goals, and a set of tools they can use. Create a Python file (e.g., content_crew.py) and begin by importing necessary classes: from crewai import Agent, Task, Crew, Process and from crewai_tools import SerperDevTool. SerperDevTool is an example search tool; you'll need a Serper API key for it. Set it as an environment variable: export SERPER_API_KEY='your_serper_api_key_here'.
Now, define your agents. For a content writing workflow, let's create a "Researcher" and a "Writer". The researcher will use the search tool to gather information. The writer will then use that information to draft the content. Give them descriptive backstories to guide their behavior.
search_tool = SerperDevTool()
researcher = Agent(
role='Senior Research Analyst',
goal='Uncover groundbreaking insights on autonomous AI agents',
backstory='A meticulous researcher passionate about staying ahead of AI trends, known for in-depth analysis.',
verbose=True,
allow_delegation=False,
tools=[search_tool]
)
writer = Agent(
role='Expert Content Writer',
goal='Create compelling and informative blog posts on AI topics',
backstory='A skilled writer capable of transforming complex AI concepts into engaging and accessible content.',
verbose=True,
allow_delegation=False
)
Define the Tasks for Your Agents
Next, define the specific tasks that each agent will undertake. Tasks include a description of what needs to be done, which agent is responsible, and any expected output. In our content creation example, the researcher will be tasked with gathering information, and the writer with drafting the article.
For the researcher, the task involves performing web searches. For the writer, it means synthesizing the research findings into an engaging blog post. You can define tasks like this:
research_task = Task(
description=(
'Identify the latest trends, challenges, and significant open-source frameworks '
'in the field of agentic AI. Focus on frameworks that empower LLMs with autonomy.'
'Compile a comprehensive report with key findings, data, and relevant examples.'
),
expected_output='A detailed research report on open-source agentic AI frameworks.',
agent=researcher
)
write_task = Task(
description=(
'Using the research report, write a compelling, SEO-optimized blog post of at least 1500 words '
'detailing the rise of agentic AI and benchmarking leading open-source frameworks.'
'The article should be engaging, informative, and provide practical insights for developers.'
'Ensure it highlights the architectural components and real-world applications.'
),
expected_output='A full SEO-optimized blog post in clean HTML format, ready for publication.',
agent=writer
)
Assemble the Crew and Kick Off the Process
With agents and tasks defined, the final step is to assemble the crew and define the process by which they will collaborate. CrewAI supports sequential processes, where tasks are executed one after another, passing outputs between agents. Create a Crew instance, providing the list of agents and tasks, and specifying the process type.
Set verbose=True to see the agents' thoughts and actions as they execute the tasks, which is invaluable for debugging and understanding their workflow. Then, call the kickoff() method to start the agentic process. The output of the last task will be the final result of the crew's work.
# Instantiate your crew with a sequential process
content_crew = Crew(
agents=[researcher, writer],
tasks=[research_task, write_task],
verbose=True, # You can set it to 1 or 2 for more detailed logs
process=Process.sequential # All tasks are executed in a sequential manner
)
# Kickoff the crew's work!
result = content_crew.kickoff()
print("\n\n###############################")
print("## Here is the final blog post:")
print("###############################\n")
print(result)
For more complex workflows, consider introducing an "Editor" agent to review and refine the output of the "Writer" agent, creating a chain of tasks that simulates a professional editorial process. This enhances the quality of the final content.
Monitor and Refine Agent Behavior
As your crew runs, closely monitor the verbose output in your terminal. This logging provides insights into each agent's thought process, chosen actions, and tool usage. Look for instances where an agent might be stuck, providing irrelevant information, or misinterpreting a task. This is where the iterative refinement comes into play.
If you observe suboptimal behavior, you can refine your agent definitions by adjusting their backstory, specifying more granular goal parameters, or modifying the description of tasks to be clearer and more restrictive. You might also need to add or remove specific tools to guide their capabilities.
For example, if the writer agent struggles with formatting, you might add a specific instruction in its task description about HTML formatting, or even add a "Formatting Tool" to its toolkit. Regular monitoring and iterative adjustments are crucial for optimizing agent performance and achieving desired outcomes.
What Does the Future Hold for Open Source Agentic AI Frameworks?
The future for open source agentic AI frameworks is poised for rapid evolution, characterized by increased sophistication in planning, enhanced reliability, greater integration with real-world systems, and a growing emphasis on explainability and ethical governance. These frameworks are at the forefront of AI innovation.
We can expect advanced reasoning capabilities, moving beyond simple task decomposition to more strategic, long-term planning and meta-reasoning, where agents can reflect on their own performance and learning. The integration of various modalities (vision, audio) will also expand their interaction capabilities dramatically.
As these frameworks mature, they will become indispensable tools for automation across industries, from scientific discovery and software engineering to customer service and creative endeavors, fundamentally changing how we interact with intelligent systems. The open-source community will play a vital role in accelerating this transformation.
How Will Agent Planning and Execution Evolve?
Agent planning and execution are expected to evolve significantly, moving towards more hierarchical, adaptive, and long-horizon planning capabilities, allowing agents to manage highly complex projects over extended periods. This progression will enhance their practical utility dramatically.
Future frameworks will likely incorporate advanced techniques like "tree-of-thought" and "graph-of-thought" reasoning more seamlessly, enabling agents to explore multiple plausible paths and backtrack efficiently. Meta-planning, where agents can reflect on and improve their planning strategies, will also become more prevalent.
Execution will become more robust, with better error recovery mechanisms, dynamic resource allocation, and real-time adaptation to unforeseen circumstances, making agents more resilient and reliable in unstructured environments. The goal is truly autonomous, intelligent problem-solving over time.
What Integrations and Applications Will Dominate?
Integrations and applications of open source agentic AI frameworks will increasingly dominate in areas requiring intelligent automation, sophisticated data analysis, and proactive system management. Their ability to orchestrate complex operations makes them highly versatile.
We'll see deeper integration with enterprise resource planning (ERP) systems, customer relationship management (CRM) platforms, and cloud infrastructure, enabling end-to-end automation of business processes. In software development, agents will play larger roles in code generation, testing, and deployment.
Domain-specific applications, such as medical diagnostics, financial market analysis, and scientific research automation, will greatly benefit from multi-agent systems that can synthesize vast amounts of information and execute complex experimental procedures. The scope of their influence is set to broaden considerably.
How Will Explainability and Trust Be Addressed?
Explainability and trust will be addressed in future open source agentic AI frameworks through the development of clearer audit trails, more transparent reasoning processes, and user-friendly interfaces for human oversight and intervention. Building user confidence is paramount for adoption.
Frameworks will provide enhanced logging and visualization tools that allow developers and end-users to understand why an agent made a particular decision or executed a specific action. This "post-hoc" explainability will be crucial for debugging and compliance.
Furthermore, agents will be designed with built-in mechanisms for self-explanation and even argumentation, allowing them to justify their choices in natural language. This combination of transparency and control will foster greater trust and facilitate responsible deployment in sensitive domains.
- Open Source Frameworks: Free to download and use, but require users to manage their own infrastructure and pay for LLM API usage.
- Managed Services: Some providers offer hosted versions of open-source frameworks or paid proprietary alternatives with subscription-based pricing, handling infrastructure and offering dedicated support.
- Custom Development: Costs vary widely based on complexity and expertise required for bespoke agentic solutions.
Conclusion
The rise of the open source agentic AI framework marks a pivotal moment in the evolution of artificial intelligence, transforming large language models from passive generators into autonomous, goal-oriented entities capable of complex problem-solving. Frameworks like CrewAI and AutoGen exemplify this shift, enabling LLMs to plan, act, and collaborate with tools and other agents to achieve sophisticated objectives.
These frameworks are built upon essential architectural patterns such as ReAct and robust planning-execution loops, allowing for dynamic adaptation and intelligent decision-making. While challenges like reliability, computational costs, and ethical considerations persist, ongoing research and community collaboration are actively pushing the boundaries of what autonomous agents can accomplish.
As these technologies mature, they promise to revolutionize industries by automating complex workflows, enhancing data analysis, and fostering entirely new forms of human-AI collaboration. The future of agentic AI, driven by the transparent and collaborative spirit of open source, is poised to unlock unprecedented levels of efficiency and innovation.
- Empowers LLMs: Agentic frameworks give LLMs the ability to plan, act, and use tools, moving beyond simple conversational capabilities.
- Multi-Agent Collaboration: Tools like CrewAI and AutoGen facilitate structured teamwork among AI agents for complex tasks.
- Core Components: Effective agents rely on planning, memory, and modular tool integration to achieve their goals.
- Practical Applications: Agents are increasingly automating tasks in content creation, software development, and data analysis.
- Future Outlook: Expect advancements in planning, reliability, ethical governance, and deep integration across various industries.
Embrace the agent uprising and start building your own intelligent, autonomous systems today. The open-source community provides the tools; your creativity provides the vision. Explore the possibilities and become part of the next wave of AI innovation.