Name: Towards AI Legal Name: Towards AI, Inc. Description: Towards AI is the world's leading artificial intelligence (AI) and technology publication. Read by thought-leaders and decision-makers around the world. Phone Number: +1-650-246-9381 Email: pub@towardsai.net
228 Park Avenue South New York, NY 10003 United States
Website: Publisher: https://towardsai.net/#publisher Diversity Policy: https://towardsai.net/about Ethics Policy: https://towardsai.net/about Masthead: https://towardsai.net/about
Name: Towards AI Legal Name: Towards AI, Inc. Description: Towards AI is the world's leading artificial intelligence (AI) and technology publication. Founders: Roberto Iriondo, , Job Title: Co-founder and Advisor Works for: Towards AI, Inc. Follow Roberto: X, LinkedIn, GitHub, Google Scholar, Towards AI Profile, Medium, ML@CMU, FreeCodeCamp, Crunchbase, Bloomberg, Roberto Iriondo, Generative AI Lab, Generative AI Lab Denis Piffaretti, Job Title: Co-founder Works for: Towards AI, Inc. Louie Peters, Job Title: Co-founder Works for: Towards AI, Inc. Louis-François Bouchard, Job Title: Co-founder Works for: Towards AI, Inc. Cover:
Towards AI Cover
Logo:
Towards AI Logo
Areas Served: Worldwide Alternate Name: Towards AI, Inc. Alternate Name: Towards AI Co. Alternate Name: towards ai Alternate Name: towardsai Alternate Name: towards.ai Alternate Name: tai Alternate Name: toward ai Alternate Name: toward.ai Alternate Name: Towards AI, Inc. Alternate Name: towardsai.net Alternate Name: pub.towardsai.net
5 stars – based on 497 reviews

Frequently Used, Contextual References

TODO: Remember to copy unique IDs whenever it needs used. i.e., URL: 304b2e42315e

Resources

Take our 85+ lesson From Beginner to Advanced LLM Developer Certification: From choosing a project to deploying a working product this is the most comprehensive and practical LLM course out there!

Publication

The Agentic AI Era: A Primer
Latest   Machine Learning

The Agentic AI Era: A Primer

Last Updated on January 16, 2025 by Editorial Team

Author(s): Kaush B

Originally published on Towards AI.

GenAI, Agentic AI, Advanced AI

Photo by Marija Zaric on Unsplash

Content

  • Introduction to Holistic Intelligence (HI)
  • What are AI Agents?
  • Types of AI Agents
  • AI Agent Architecture: Topologies
  • Enterprise AI Agents: Characteristics and Stages
  • Agentic Workflows
  • Agentic Design Patterns
  • Implementation Guidelines
  • Technical Risks
  • Design Principles for Technical Risk Mitigation

Introduction to Holistic Intelligence (HI)

General-purpose AI (AI that can perform a wide variety of tasks) capabilities have grown rapidly in recent years. An AI agent is as an interactive system that interacts with environments using its perceptual abilities, performing actions that align with human intentions. With the help of AI agents, virtually any business — ranging from individual contributors to executives — will have the ability to manage not only human workforce, but also digital labor. This offers a promising pathway towards Artificial General Intelligence (AGI) or Holistic Intelligence (HI).

Source: Arxiv

Agentic AI operates in both physical and virtual worlds by leveraging cross-modal data that is acquired through interactions across diverse environments. Integrating LLMs (large Language Models) and LMMs (Large Multimodal Models) enhances agentic AI systems, making them more intelligent, adaptable, and able to handle a wide array of tasks across diverse use cases.

Source: Arxiv

What are AI Agents?

AI agents are self-directed systems that sense their surroundings, make decisions, and exercise autonomy to accomplish specific objectives. Their operations can be broken down into four fundamental steps:

  1. Leverage Perception Module to collect pertinent data to grasp the context. Data can be collected from environments via sensors or ingested from external sources or accessed from memory containing historical interaction data.
  2. Leverage Cognitive Module to evaluate the task, identify the required actions, strategize the task by breaking it down into manageable steps, and analysing the data to determine the most effective approach. This module is enabled and powered by LLMs/LMMs.
  3. Leverage Action Module to carry out the task by using knowledge and tools to complete it, whether by delivering information or triggering an action.
  4. Leverage Learning Module to reflect on the outcomes of the action to enhance future performance.
Source: UC Berkeley

Types of AI Agents

World Economic Forum has categorized AI agents into the following types:

1. Simple Reflex Agents

Simple reflex agents rely on predefined condition-action rules to respond to environmental stimuli without considering past experiences. These rule-based systems are static, providing rapid but inflexible responses to specific inputs. Examples:

  • Keyword-based spam filters
  • Preprogrammed chatbots
  • Automated email replies

2. Model-based Reflex Agents

Model-based reflex agents use stored information from past observations to track unseen parts of their environment, enabling them to make decisions based on both current inputs and their internal model. This adaptability makes them more advanced than simple reflex agents, despite also relying on condition-action rules. Examples:

  • Smart thermostats
  • Intelligent robotic vacuum cleaners
  • Advanced sensor-based irrigation systems

3. Goal-based agents

Goal-based agents evaluate future scenarios and plan actions based on the desirability of their outcomes to achieve specific objectives. By using goal-oriented planning algorithms, they excel in complex decision-making tasks. Examples:

  • AI chess engines
  • Route optimization systems
  • Customer service chatbots

4. Utility-based agents

Utility-based agents leverage utility functions and decision theory to evaluate and prioritize potential outcomes, enabling optimal decision-making in complex scenarios with uncertainty or conflicting goals. This approach allows them to balance multiple objectives based on their relative significance. Examples:

  • Autonomous driving systems
  • Portfolio management systems
  • Healthcare diagnosis assistants

AI Agent Architecture: Topologies

Agentic AI systems demand a robust and adaptable architecture that mirrors the processes humans use, both individually and collectively, to tackle complex tasks. These agents can function autonomously or cooperate within networks that feature varying topologies. A single agent system architecture involves 1 agent.

Multi-agent systems (MAS) involve more than 1 agents and may be found in 2 different topologies.

  • Vertical Architecture or Supervised Architecture: In this model, a “supervisor” agent manages interactions among other agents when their goals diverge, helping prioritize the system’s objectives and find a compromise. For example, if a buyer and seller agent can’t reach an agreement, the supervisor mediates the transaction.
  • Network Architecture: In this model, agents or systems communicate to align with the MAS objectives, such as autonomous vehicles coordinating to avoid collisions while parking in tight spaces, ensuring both individual and collective goals of safety are met.
Source: World Economic Forum

Enterprise AI Agents: Characteristics and Stages

An agentic AI system is characterized by the following capabilities:

  • Autonomy: The ability to initiate and complete tasks independently, requiring minimal or no direct human supervision. This grants the AI greater flexibility in its operations and enhances efficiency in task execution.
  • Reasoning: The capacity to make informed decisions based on contextual analysis, enabling sophisticated judgment.
  • Reinforced Learning: The ability to continuously improve and adapt through interaction with its environment, learning from feedback.
  • Language Understanding: The ability to comprehend and adhere to complex instructions, ensuring effective communication and execution.
  • Workflow Optimization: The capability to efficiently manage and execute multi-step processes, streamlining operations.

We are at the beginning of a three-stage future for Enterprise AI agents.

Stage 1: Single Agents (Specialized Contributor)

Source: Salesforce

In the first stage of agentic evolution, specialized agents enhance business efficiency by excelling at defined tasks within specific industries, offering personalized AI-driven insights and high-quality generative guidance to optimize workflows, customer interactions, and marketing. These agents lay the groundwork for broader enterprise AI adoption, revolutionizing routine operations with speed, accuracy, and personalization.

Stage 2: Collaborative Agents (Coordinated Agents)

Source: Salesforce

This stage involves an orchestrator agent coordinating specialized agents within a company, much like a restaurant’s general manager overseeing various roles to achieve a shared business goal.

Stage 3: Agent Ecosystems (Ensemble Orchestrators)

Source: Salesforce

The final stage introduces advanced agent-to-agent (A2A) interactions across organizations, evolving beyond traditional business models into B2A and B2A2C, where AI agents act as intermediaries. This complexity will drive sophisticated enterprise processes, necessitating advanced negotiation, risk management, and conflict resolution skills as AI orchestrates personalized, meaningful collaboration across industries.

Agentic Workflows

When LLM calls are viewed as enhanced with augmentations such as retrieval, tools, and memory, the following agentic workflows can be defined.

1. Prompt Chaining

Prompt chaining breaks a task into smaller steps, where each LLM call builds on the previous one, with programmatic checks ensuring accuracy. It’s ideal for tasks that can be decomposed into fixed subtasks which are sequential in nature, improving accuracy at the cost of latency.

Source: Anthropic

2. Routing

Routing classifies inputs and directs them to specialized follow-up tasks, optimizing performance by handling distinct categories separately. It is useful for complex tasks with clear categories, such as directing customer service queries or routing questions to models of varying capabilities.

Source: Anthropic

3. Parallelization

This approach is useful when tasks can be split for speed or when multiple perspectives are needed for higher confidence results. For complex tasks, parallelization improves performance by having different LLMs focus on specific considerations. Examples include running multiple prompts to review code. LLMs can be used in parallel to perform tasks more efficiently, with two key variations:

  • Sectioning, where a task is broken into independent subtasks, and
  • Voting, where the same task is run multiple times for diverse outputs.
Source: Anthropic

4. Orchestrator-workers

The orchestrator-workers workflow involves a central LLM breaking down complex tasks into dynamic subtasks, which are delegated to worker LLMs, with results synthesized afterward. This workflow is ideal for tasks with unpredictable subtasks, such as coding or search tasks, where flexibility is key.

Source: Anthropic

5. Evaluator-optimizer

The evaluator-optimizer workflow involves one LLM generating a response and another providing evaluation and feedback in an iterative loop, making it effective when clear evaluation criteria exist, and iterative refinement offers measurable value. It is useful in tasks like literary translation or complex search tasks, where feedback and adjustments improve the final outcome.

Source: Anthropic

Agentic Design Patterns

According to a framework proposed by Andrew Ng for categorizing design patterns to build agents, there are 4 fundamental agentic design patterns.

1. Reflection

In this pattern, the LLM examines its own work to come up with ways to improve it. The process of self-reflection allows an LLM to improve its output by identifying gaps and refining its work across tasks. This can be enhanced with tools like unit tests and web searches for validation, and further strengthened by using a multi-agent framework where one agent generates content and another offers constructive criticism.

Source: Andrew Ng

2. Tool Use

In this pattern, the LLM is given tools such as web search, code execution, or any other function to help it gather information, take action, or process data. Developers have expanded the capabilities of LLMs by integrating web search and other tools, allowing the models to dynamically retrieve information and perform tasks beyond token generation. This approach involves fine-tuning or prompting the model to use various functions, such as web search, productivity tools, and more, while selecting relevant functions based on the current context, much like retrieval-augmented generation (RAG) systems.

Source: Andrew Ng

3. Planning

In this pattern, the LLM comes up with, and executes, a multistep plan to achieve a goal (for example, writing an outline for an essay, then doing online research, then writing a draft, and so on). Planning is an agentic AI design pattern where a large language model (LLM) autonomously decides on the sequence of steps to accomplish a task, such as breaking down a larger objective into smaller subtasks. While many tasks don’t require planning and can follow a fixed, deterministic sequence, complex tasks benefit from the agent’s ability to dynamically choose the steps to take. Though planning is powerful, it leads to less predictable outcomes compared to other agentic patterns like Reflection and Tool Use, which are more reliable. However, as the field evolves, planning technology is expected to improve quickly.

Source: Andrew Ng

4. Multi-agent Collaboration

In this pattern, more than one AI agent work together, splitting up tasks and discussing and debating ideas, to come up with better solutions than a single agent would. A multi-agent approach to complex tasks, such as software development, involves breaking the task into subtasks assigned to roles like engineers, product managers, and QA specialists, with different agents completing each subtask. Frameworks like AutoGen, Crew AI, and LangGraph enable the creation of such multi-agent solutions. However, the quality of output from multi-agent collaboration can be unpredictable, especially when agents interact freely and use multiple tools. More established patterns like Reflection and Tool Use tend to yield more reliable results.

Source: Andrew Ng

Implementation Guidelines

When to Use Agents

Agents are suited for open-ended problems, where predicting the exact number of steps is challenging or unfeasible, and where a fixed path cannot be hard-coded. In such scenarios, the LLM may need to operate over multiple turns, requiring a certain level of trust in its decision-making process. Due to their autonomy, agents are well-suited for scaling tasks in trusted environments.

However, the autonomous nature of agents also brings higher costs and the risk of compounding errors. Therefore, it is necessary to conduct thorough testing in controlled environments and implement suitable safeguards.

When Not to Use Agents

When developing applications with LLMs, one should opt for the simplest solution and add complexity only when necessary. This may mean avoiding the creation of agentic systems altogether. Agentic systems typically sacrifice latency and cost for improved task performance, so it’s important to evaluate when this trade-off is justifiable.

If more complexity is required, deterministic workflows provide predictability and consistency for tasks with clear definitions, while agents are better suited for tasks requiring flexibility and model-driven decision-making at scale. However, for many applications, enhancing individual LLM calls with retrieval and in-context examples is often sufficient.

One doesn’t need agents always to solve complex business problems. Agentless is a non-agent framework adopted by OpenAI. Agentless is a great example of how focusing on solving problems can avoid the complexity and pitfalls of agent-based systems.

When (and When Not) to Use AI Agent Frameworks

There are many frameworks which simplify the process of getting started by handling standard low-level tasks such as calling LLMs, defining and parsing tools, and chaining calls. However, these frameworks can introduce additional layers of abstraction, potentially hiding the underlying prompts and responses, which makes debugging more difficult. They may also encourage unnecessary complexity, even when a simpler setup would suffice.

Therefore, developers should begin by using LLM APIs directly, as many patterns can be implemented in just a few lines of code. Before using a framework, one should ensure to fully understand the underlying code. Misunderstandings about the core functionality are a common source of errors.

Technical Risks

The emergence of agentic AI presents profound risks and governance challenges. These risks can be categorized into Technical, Socioeconomic, and Ethical Risks. In order to keep the discussion focused on technical aspects only, let’s elaborate the technical risks alone.

AI Agent Failures and Malfunctions

AI agents can introduce new failure modes, such as generating plausible but incorrect outputs, alongside traditional issues like sensor inaccuracies, capability failures (due to limitations in task execution), and goal-related failures (pursuing the wrong objectives), which also heighten security risks.

  • Specification Gaming: AI agents exploit programming loopholes or shortcuts to achieve objectives without properly fulfilling their intended goals.
  • Goal Mis-generalization: AI agents misapply their learned goals in new or unexpected situations.
  • Deceptive Alignment: AI agents may seem aligned with intended goals during training or testing, but their internal objectives can diverge from the intended purpose.

Malicious Usage and Security Threats

AI agents can increase the volume, sophistication, and personalization of scams and cyberattacks, automating complex tasks that lower barriers for malicious activities and enabling large-scale operations with minimal expertise.

Difficulties in Validating AI agents

The lack of transparency and nondeterministic behavior in AI agents poses challenges for validation in critical applications, where designing fail-safe mechanisms is complicated by uncertain failure modes.

Design Principles for Technical Risk Mitigation

The National Engineering Policy Centre at the Royal Academy of Engineering, UK, hosted a cross-sector workshop on the role of international technical standards in regulating autonomous systems. Three principles were discussed and presented in IEEE:

1. Transparency: Transparency in autonomous and intelligent systems (A/IS) ensures decisions and actions are fostering trust. The IEEE P7001 standard defines measurable transparency levels for diverse stakeholders, from expert engineers to non-expert users, ensuring accessible and clear communication, along with proper documentation.

2. Failsafe Design: The IEEE P7009 standard establishes guidelines for designing, implementing, and certifying fail-safe mechanisms in autonomous and semi-autonomous systems to mitigate risks to people, society, and the environment. It provides tools, methods, and sector-specific adaptations to ensure these systems can fail safely under varying contexts.

3. Verifiability: The IEEE P2817 Guide for verifying autonomous systems provides a structured, multi-step process to ensure system reliability, leveraging formal methods, simulations, stochastic approaches, real-world testing, and runtime verification. It highlights the importance of evidence of reliability and adherence to ethical principles, addressing regulatory challenges and gaps while fostering confidence in autonomous system design and decision-making.

Conclusion

The Agentic AI Era marks a transformative phase in artificial intelligence, where AI systems evolve from tools of automation to autonomous agents capable of proactive decision-making. Unlike traditional AI models, agentic AI exhibits self-directed behavior, adapting dynamically to complex environments and tasks. This era brings profound changes across industries, enabling personalized solutions, streamlining decision-making, and fostering innovations previously thought unattainable.

However, the rise of agentic AI also introduces significant ethical, societal, and regulatory challenges. Questions about accountability, transparency, and unintended consequences must be addressed to ensure the responsible deployment of these systems. As we navigate this uncharted territory, the focus will be on leveraging the benefits of agentic AI while mitigating risks, shaping a future where humans and intelligent agents collaborate seamlessly to unlock unprecedented potential.

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI

Feedback ↓

Sign Up for the Course
`; } else { console.error('Element with id="subscribe" not found within the page with class "home".'); } } }); // Remove duplicate text from articles /* Backup: 09/11/24 function removeDuplicateText() { const elements = document.querySelectorAll('h1, h2, h3, h4, h5, strong'); // Select the desired elements const seenTexts = new Set(); // A set to keep track of seen texts const tagCounters = {}; // Object to track instances of each tag elements.forEach(el => { const tagName = el.tagName.toLowerCase(); // Get the tag name (e.g., 'h1', 'h2', etc.) // Initialize a counter for each tag if not already done if (!tagCounters[tagName]) { tagCounters[tagName] = 0; } // Only process the first 10 elements of each tag type if (tagCounters[tagName] >= 2) { return; // Skip if the number of elements exceeds 10 } const text = el.textContent.trim(); // Get the text content const words = text.split(/\s+/); // Split the text into words if (words.length >= 4) { // Ensure at least 4 words const significantPart = words.slice(0, 5).join(' '); // Get first 5 words for matching // Check if the text (not the tag) has been seen before if (seenTexts.has(significantPart)) { // console.log('Duplicate found, removing:', el); // Log duplicate el.remove(); // Remove duplicate element } else { seenTexts.add(significantPart); // Add the text to the set } } tagCounters[tagName]++; // Increment the counter for this tag }); } removeDuplicateText(); */ // Remove duplicate text from articles function removeDuplicateText() { const elements = document.querySelectorAll('h1, h2, h3, h4, h5, strong'); // Select the desired elements const seenTexts = new Set(); // A set to keep track of seen texts const tagCounters = {}; // Object to track instances of each tag // List of classes to be excluded const excludedClasses = ['medium-author', 'post-widget-title']; elements.forEach(el => { // Skip elements with any of the excluded classes if (excludedClasses.some(cls => el.classList.contains(cls))) { return; // Skip this element if it has any of the excluded classes } const tagName = el.tagName.toLowerCase(); // Get the tag name (e.g., 'h1', 'h2', etc.) // Initialize a counter for each tag if not already done if (!tagCounters[tagName]) { tagCounters[tagName] = 0; } // Only process the first 10 elements of each tag type if (tagCounters[tagName] >= 10) { return; // Skip if the number of elements exceeds 10 } const text = el.textContent.trim(); // Get the text content const words = text.split(/\s+/); // Split the text into words if (words.length >= 4) { // Ensure at least 4 words const significantPart = words.slice(0, 5).join(' '); // Get first 5 words for matching // Check if the text (not the tag) has been seen before if (seenTexts.has(significantPart)) { // console.log('Duplicate found, removing:', el); // Log duplicate el.remove(); // Remove duplicate element } else { seenTexts.add(significantPart); // Add the text to the set } } tagCounters[tagName]++; // Increment the counter for this tag }); } removeDuplicateText(); //Remove unnecessary text in blog excerpts document.querySelectorAll('.blog p').forEach(function(paragraph) { // Replace the unwanted text pattern for each paragraph paragraph.innerHTML = paragraph.innerHTML .replace(/Author\(s\): [\w\s]+ Originally published on Towards AI\.?/g, '') // Removes 'Author(s): XYZ Originally published on Towards AI' .replace(/This member-only story is on us\. Upgrade to access all of Medium\./g, ''); // Removes 'This member-only story...' }); //Load ionic icons and cache them if ('localStorage' in window && window['localStorage'] !== null) { const cssLink = 'https://code.ionicframework.com/ionicons/2.0.1/css/ionicons.min.css'; const storedCss = localStorage.getItem('ionicons'); if (storedCss) { loadCSS(storedCss); } else { fetch(cssLink).then(response => response.text()).then(css => { localStorage.setItem('ionicons', css); loadCSS(css); }); } } function loadCSS(css) { const style = document.createElement('style'); style.innerHTML = css; document.head.appendChild(style); } //Remove elements from imported content automatically function removeStrongFromHeadings() { const elements = document.querySelectorAll('h1, h2, h3, h4, h5, h6, span'); elements.forEach(el => { const strongTags = el.querySelectorAll('strong'); strongTags.forEach(strongTag => { while (strongTag.firstChild) { strongTag.parentNode.insertBefore(strongTag.firstChild, strongTag); } strongTag.remove(); }); }); } removeStrongFromHeadings(); "use strict"; window.onload = () => { /* //This is an object for each category of subjects and in that there are kewords and link to the keywods let keywordsAndLinks = { //you can add more categories and define their keywords and add a link ds: { keywords: [ //you can add more keywords here they are detected and replaced with achor tag automatically 'data science', 'Data science', 'Data Science', 'data Science', 'DATA SCIENCE', ], //we will replace the linktext with the keyword later on in the code //you can easily change links for each category here //(include class="ml-link" and linktext) link: 'linktext', }, ml: { keywords: [ //Add more keywords 'machine learning', 'Machine learning', 'Machine Learning', 'machine Learning', 'MACHINE LEARNING', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, ai: { keywords: [ 'artificial intelligence', 'Artificial intelligence', 'Artificial Intelligence', 'artificial Intelligence', 'ARTIFICIAL INTELLIGENCE', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, nl: { keywords: [ 'NLP', 'nlp', 'natural language processing', 'Natural Language Processing', 'NATURAL LANGUAGE PROCESSING', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, des: { keywords: [ 'data engineering services', 'Data Engineering Services', 'DATA ENGINEERING SERVICES', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, td: { keywords: [ 'training data', 'Training Data', 'training Data', 'TRAINING DATA', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, ias: { keywords: [ 'image annotation services', 'Image annotation services', 'image Annotation services', 'image annotation Services', 'Image Annotation Services', 'IMAGE ANNOTATION SERVICES', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, l: { keywords: [ 'labeling', 'labelling', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, pbp: { keywords: [ 'previous blog posts', 'previous blog post', 'latest', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, mlc: { keywords: [ 'machine learning course', 'machine learning class', ], //Change your article link (include class="ml-link" and linktext) link: 'linktext', }, }; //Articles to skip let articleIdsToSkip = ['post-2651', 'post-3414', 'post-3540']; //keyword with its related achortag is recieved here along with article id function searchAndReplace(keyword, anchorTag, articleId) { //selects the h3 h4 and p tags that are inside of the article let content = document.querySelector(`#${articleId} .entry-content`); //replaces the "linktext" in achor tag with the keyword that will be searched and replaced let newLink = anchorTag.replace('linktext', keyword); //regular expression to search keyword var re = new RegExp('(' + keyword + ')', 'g'); //this replaces the keywords in h3 h4 and p tags content with achor tag content.innerHTML = content.innerHTML.replace(re, newLink); } function articleFilter(keyword, anchorTag) { //gets all the articles var articles = document.querySelectorAll('article'); //if its zero or less then there are no articles if (articles.length > 0) { for (let x = 0; x < articles.length; x++) { //articles to skip is an array in which there are ids of articles which should not get effected //if the current article's id is also in that array then do not call search and replace with its data if (!articleIdsToSkip.includes(articles[x].id)) { //search and replace is called on articles which should get effected searchAndReplace(keyword, anchorTag, articles[x].id, key); } else { console.log( `Cannot replace the keywords in article with id ${articles[x].id}` ); } } } else { console.log('No articles found.'); } } let key; //not part of script, added for (key in keywordsAndLinks) { //key is the object in keywords and links object i.e ds, ml, ai for (let i = 0; i < keywordsAndLinks[key].keywords.length; i++) { //keywordsAndLinks[key].keywords is the array of keywords for key (ds, ml, ai) //keywordsAndLinks[key].keywords[i] is the keyword and keywordsAndLinks[key].link is the link //keyword and link is sent to searchreplace where it is then replaced using regular expression and replace function articleFilter( keywordsAndLinks[key].keywords[i], keywordsAndLinks[key].link ); } } function cleanLinks() { // (making smal functions is for DRY) this function gets the links and only keeps the first 2 and from the rest removes the anchor tag and replaces it with its text function removeLinks(links) { if (links.length > 1) { for (let i = 2; i < links.length; i++) { links[i].outerHTML = links[i].textContent; } } } //arrays which will contain all the achor tags found with the class (ds-link, ml-link, ailink) in each article inserted using search and replace let dslinks; let mllinks; let ailinks; let nllinks; let deslinks; let tdlinks; let iaslinks; let llinks; let pbplinks; let mlclinks; const content = document.querySelectorAll('article'); //all articles content.forEach((c) => { //to skip the articles with specific ids if (!articleIdsToSkip.includes(c.id)) { //getting all the anchor tags in each article one by one dslinks = document.querySelectorAll(`#${c.id} .entry-content a.ds-link`); mllinks = document.querySelectorAll(`#${c.id} .entry-content a.ml-link`); ailinks = document.querySelectorAll(`#${c.id} .entry-content a.ai-link`); nllinks = document.querySelectorAll(`#${c.id} .entry-content a.ntrl-link`); deslinks = document.querySelectorAll(`#${c.id} .entry-content a.des-link`); tdlinks = document.querySelectorAll(`#${c.id} .entry-content a.td-link`); iaslinks = document.querySelectorAll(`#${c.id} .entry-content a.ias-link`); mlclinks = document.querySelectorAll(`#${c.id} .entry-content a.mlc-link`); llinks = document.querySelectorAll(`#${c.id} .entry-content a.l-link`); pbplinks = document.querySelectorAll(`#${c.id} .entry-content a.pbp-link`); //sending the anchor tags list of each article one by one to remove extra anchor tags removeLinks(dslinks); removeLinks(mllinks); removeLinks(ailinks); removeLinks(nllinks); removeLinks(deslinks); removeLinks(tdlinks); removeLinks(iaslinks); removeLinks(mlclinks); removeLinks(llinks); removeLinks(pbplinks); } }); } //To remove extra achor tags of each category (ds, ml, ai) and only have 2 of each category per article cleanLinks(); */ //Recommended Articles var ctaLinks = [ /* ' ' + '

Subscribe to our AI newsletter!

' + */ '

Take our 85+ lesson From Beginner to Advanced LLM Developer Certification: From choosing a project to deploying a working product this is the most comprehensive and practical LLM course out there!

'+ '

Towards AI has published Building LLMs for Production—our 470+ page guide to mastering LLMs with practical projects and expert insights!

' + '
' + '' + '' + '

Note: Content contains the views of the contributing authors and not Towards AI.
Disclosure: This website may contain sponsored content and affiliate links.

' + 'Discover Your Dream AI Career at Towards AI Jobs' + '

Towards AI has built a jobs board tailored specifically to Machine Learning and Data Science Jobs and Skills. Our software searches for live AI jobs each hour, labels and categorises them and makes them easily searchable. Explore over 10,000 live jobs today with Towards AI Jobs!

' + '
' + '

🔥 Recommended Articles 🔥

' + 'Why Become an LLM Developer? Launching Towards AI’s New One-Stop Conversion Course'+ 'Testing Launchpad.sh: A Container-based GPU Cloud for Inference and Fine-tuning'+ 'The Top 13 AI-Powered CRM Platforms
' + 'Top 11 AI Call Center Software for 2024
' + 'Learn Prompting 101—Prompt Engineering Course
' + 'Explore Leading Cloud Providers for GPU-Powered LLM Training
' + 'Best AI Communities for Artificial Intelligence Enthusiasts
' + 'Best Workstations for Deep Learning
' + 'Best Laptops for Deep Learning
' + 'Best Machine Learning Books
' + 'Machine Learning Algorithms
' + 'Neural Networks Tutorial
' + 'Best Public Datasets for Machine Learning
' + 'Neural Network Types
' + 'NLP Tutorial
' + 'Best Data Science Books
' + 'Monte Carlo Simulation Tutorial
' + 'Recommender System Tutorial
' + 'Linear Algebra for Deep Learning Tutorial
' + 'Google Colab Introduction
' + 'Decision Trees in Machine Learning
' + 'Principal Component Analysis (PCA) Tutorial
' + 'Linear Regression from Zero to Hero
'+ '

', /* + '

Join thousands of data leaders on the AI newsletter. It’s free, we don’t spam, and we never share your email address. Keep up to date with the latest work in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

',*/ ]; var replaceText = { '': '', '': '', '
': '
' + ctaLinks + '
', }; Object.keys(replaceText).forEach((txtorig) => { //txtorig is the key in replacetext object const txtnew = replaceText[txtorig]; //txtnew is the value of the key in replacetext object let entryFooter = document.querySelector('article .entry-footer'); if (document.querySelectorAll('.single-post').length > 0) { //console.log('Article found.'); const text = entryFooter.innerHTML; entryFooter.innerHTML = text.replace(txtorig, txtnew); } else { // console.log('Article not found.'); //removing comment 09/04/24 } }); var css = document.createElement('style'); css.type = 'text/css'; css.innerHTML = '.post-tags { display:none !important } .article-cta a { font-size: 18px; }'; document.body.appendChild(css); //Extra //This function adds some accessibility needs to the site. function addAlly() { // In this function JQuery is replaced with vanilla javascript functions const imgCont = document.querySelector('.uw-imgcont'); imgCont.setAttribute('aria-label', 'AI news, latest developments'); imgCont.title = 'AI news, latest developments'; imgCont.rel = 'noopener'; document.querySelector('.page-mobile-menu-logo a').title = 'Towards AI Home'; document.querySelector('a.social-link').rel = 'noopener'; document.querySelector('a.uw-text').rel = 'noopener'; document.querySelector('a.uw-w-branding').rel = 'noopener'; document.querySelector('.blog h2.heading').innerHTML = 'Publication'; const popupSearch = document.querySelector$('a.btn-open-popup-search'); popupSearch.setAttribute('role', 'button'); popupSearch.title = 'Search'; const searchClose = document.querySelector('a.popup-search-close'); searchClose.setAttribute('role', 'button'); searchClose.title = 'Close search page'; // document // .querySelector('a.btn-open-popup-search') // .setAttribute( // 'href', // 'https://medium.com/towards-artificial-intelligence/search' // ); } // Add external attributes to 302 sticky and editorial links function extLink() { // Sticky 302 links, this fuction opens the link we send to Medium on a new tab and adds a "noopener" rel to them var stickyLinks = document.querySelectorAll('.grid-item.sticky a'); for (var i = 0; i < stickyLinks.length; i++) { /* stickyLinks[i].setAttribute('target', '_blank'); stickyLinks[i].setAttribute('rel', 'noopener'); */ } // Editorial 302 links, same here var editLinks = document.querySelectorAll( '.grid-item.category-editorial a' ); for (var i = 0; i < editLinks.length; i++) { editLinks[i].setAttribute('target', '_blank'); editLinks[i].setAttribute('rel', 'noopener'); } } // Add current year to copyright notices document.getElementById( 'js-current-year' ).textContent = new Date().getFullYear(); // Call functions after page load extLink(); //addAlly(); setTimeout(function() { //addAlly(); //ideally we should only need to run it once ↑ }, 5000); }; function closeCookieDialog (){ document.getElementById("cookie-consent").style.display = "none"; return false; } setTimeout ( function () { closeCookieDialog(); }, 15000); console.log(`%c 🚀🚀🚀 ███ █████ ███████ █████████ ███████████ █████████████ ███████████████ ███████ ███████ ███████ ┌───────────────────────────────────────────────────────────────────┐ │ │ │ Towards AI is looking for contributors! │ │ Join us in creating awesome AI content. │ │ Let's build the future of AI together → │ │ https://towardsai.net/contribute │ │ │ └───────────────────────────────────────────────────────────────────┘ `, `background: ; color: #00adff; font-size: large`); //Remove latest category across site document.querySelectorAll('a[rel="category tag"]').forEach(function(el) { if (el.textContent.trim() === 'Latest') { // Remove the two consecutive spaces (  ) if (el.nextSibling && el.nextSibling.nodeValue.includes('\u00A0\u00A0')) { el.nextSibling.nodeValue = ''; // Remove the spaces } el.style.display = 'none'; // Hide the element } }); // Add cross-domain measurement, anonymize IPs 'use strict'; //var ga = gtag; ga('config', 'G-9D3HKKFV1Q', 'auto', { /*'allowLinker': true,*/ 'anonymize_ip': true/*, 'linker': { 'domains': [ 'medium.com/towards-artificial-intelligence', 'datasets.towardsai.net', 'rss.towardsai.net', 'feed.towardsai.net', 'contribute.towardsai.net', 'members.towardsai.net', 'pub.towardsai.net', 'news.towardsai.net' ] } */ }); ga('send', 'pageview'); -->