Agentic AI Swarm Optimization utilizing Synthetic Bee Colonization (ABC)

of Contents

📄Python Pocket book
🍯Introduction
🔍Instance ABC Agent Search Progress
⏳Agent Lifecycle in Swarm Optimization
🐝The three Bee Agent Roles
🪻Iris Dataset
❄ Clustering – No labels? No downside!
🏋️Health Mannequin for Clustering
🤔Confusion Matrix as a Diagnostic Instrument
🏃Working the Agentic AI Loop
📊Reporting Outcomes
💬Designing Agent Prompts for Gemini
⚠️Gemini Agentic AI Points
⚔️Agentic AI Aggressive Panorama in direction of 2026
✨Conclusion and Future Work

📄Python Pocket book

Discover my interactive pocket book on Google Colab — and be at liberty to attach with me on LinkedIn for any questions or suggestions.

🍯 Introduction

With the unbelievable innovation occurring round Agentic AI, I needed to get fingers‑on with a venture that integrates LLM prompts right into a Knowledge Science workflow. The Synthetic Bee Colony (ABC) algorithm is impressed by honey bees’ foraging habits and works remarkably nicely in nature. It belongs to the household of swarm intelligence algorithms, designed for decentralized choice‑making processes whereby “bee brokers” pursue their particular person targets autonomously, whereas collectively enhancing the standard of the general resolution (the “honeypot”). 

This in style approach has been extensively utilized to many fields, particularly: scheduling, routing, vitality optimization, useful resource allocation and anomaly detection. Researchers typically mix ABC with neural networks in a hybrid strategy, for instance, utilizing ABC to tune hyperparameters or optimize mannequin weights. The algorithm is especially related when knowledge is scarce or when the issue is combinatorial – when the answer area grows exponentially (and even factorially) with the variety of options.

On this venture, my strategy has been to imitate Swarm Optimization for an Adaptive Grid Search. The inventive twist is that I utilized Google’s new Agentic AI instruments to implement the bee brokers. Within the ABC algorithm, there are three sorts of autonomous bee brokers, and I outlined their roles utilizing textual content prompts powered by the most recent Gemini LLMs.

Every foraging cycle (algorithm iteration) proceeds as follows:

1. Scout bees discover → uncover new meals sources (candidate options).
2. Employed bees exploit → refine these sources and dance to share data concerning the high quality of the nectar (health operate).
3. Onlooker bees exploit additional → guided by the dances, they reinforce the colony’s deal with the very best meals sources.

🔍Instance ABC Agent Search Progress

⏳Agent Lifecycle in Swarm Optimization

The ABC algorithm was first proposed by Derviş Karaboğa in 2005. In my modernized meta‑heuristic adaptation, I centered on the objective of enhancing clustering efficiency for an unsupervised dataset.

Beneath are the Python lessons I applied:

1. WebResearcher: Accountable for researching and summarizing scikit-learn clustering algorithms and their key hyperparameters. The knowledge gathered is essential for producing correct and efficient prompts for the bee brokers, and this class is applied as an LLM‑primarily based agent.
2. ScoutBeeAgent: Generates numerous preliminary candidate clustering options for the Iris dataset, leveraging the parameter summaries offered by the WebResearcher.
3. EmployedBeeAgent: Refines present candidate options by exploring native parameter neighborhoods, utilizing the WebResearcher’s insights to make knowledgeable changes.
4. OnlookerBeeAgent: Evaluates the generated and refined candidates, choosing essentially the most promising ones to hold ahead to the following iteration.
5. Runner: Orchestrates the general ABC optimization loop, organizing and coordinating the Gemini AI agent movement. It manages sequencing between the completely different bee brokers and tracks world progress. Whereas the Runner ensures construction and oversight, every bee agent operates in a completely distributed and autonomous method, independently performing its specialised duties with out centralized management.
6. FitnessModel: Evaluates the standard of every candidate resolution utilizing the Adjusted Rand Index (ARI), with the target of minimizing 1 – ARI  to realize higher clustering options. 
7. Reporter: Visualizes the convergence of the very best ARI values over iterations and compares the highest‑performing options in opposition to baseline clustering fashions.

🐝The three Bee Agent Roles

The brokers decide parameter values and ranges via pure language prompts offered to the Gemini generative AI mannequin. All three brokers inherit from the BeeAgent base class, which handles shared setup and candidate monitoring. A part of every immediate is knowledgeable by the WebResearcher, which summarizes scikit-learn clustering algorithms algorithms and their key hyperparameters to make sure accuracy and relevance. Right here’s how every agent works:

• 🐝ScoutBeeAgent (Preliminary Parameter Technology): Constructs prompts that enable the LLM some creativity inside outlined constraints. The allowed_algorithms parameter guides which fashions to contemplate from the favored clustering algorithms in scikit‑study. The Gemini mannequin interprets these directions and generates numerous candidate options, making certain no duplicates and balanced distribution throughout algorithms.
• 🐝EmployedBeeAgent (Parameter Refinement): Generates prompts with refining directions, directing the LLM to regulate parameters by roughly ±10–20%, stay inside legitimate ranges, and keep away from inventing unsupported parameters. It takes the present options and applies these guidelines to create barely diversified (refined) candidates inside the native neighborhood of the prevailing parameter area.
• 🐝OnlookerBeeAgent (Analysis and Choice): Produces prompts that consider the candidates generated and refined by the opposite brokers. Utilizing a health rating primarily based on the Adjusted Rand Index (ARI), it selects the highest‑ok promising options, maintains algorithm variety, and avoids duplicates. This reinforces the colony’s deal with the strongest candidates.

In essence, the Python code defines the duty objective, parameters, constraints, and return values as textual content inside the prompts. The generative AI mannequin (Gemini) then “reads” and “understands” these directions to provide or modify the precise numerical and categorical parameter values for the clustering algorithms. Totally different LLMs might reply otherwise to delicate modifications within the enter textual content, so you will need to experiment with the wording of prompts for the three agent lessons. To refine the wording additional, you’ll be able to at all times seek the advice of your most well-liked LLM.

🪻Iris Dataset

A pure selection for this research is Sir Ronald Fisher’s traditional Iris flower dataset, launched in his 1936 paper. Within the subsequent sections, this dataset is utilized as a small, nicely‑outlined demonstration case as an example how the proposed ABC optimization technique will be utilized inside the context of a clustering downside.

The Iris dataset (License : CC0 1.0) contains 150 labeled samples, every belonging to one in every of 3 Iris lessons: Iris Setosa, Iris Versicolor, Iris Virginica. Every flower pattern is related to 4 numeric options: Sepal size, Sepal width, Petal size, Petal width.

As proven in each the pairwise relationship plots and the mutual data characteristic‑significance plots, petal size and petal width are by far essentially the most informative options when measured in opposition to the goal labels of the Iris dataset.

Mutual Info (MI) is computed characteristic‑sensible with respect to the labels, whereas the Adjusted Rand Index (ARI), used on this venture for health analysis, measures the settlement between two partitions (predicted cluster labels versus true labels). Observe that even when characteristic choice is utilized, since Iris Versicolor and Iris Virginica share comparable petal lengths and widths, their clusters overlap in characteristic area. Because of this, the ARI will be robust however can’t attain an ideal rating of 1.0.

❄ Clustering – No labels? No downside!

Clustering algorithms are a cornerstone of unsupervised studying and so I selected to deal with the objective of blindly figuring out the flower lessons primarily based solely on their options. In different phrases, the mannequin was not educated on the flower labels; these labels have been used solely to validate efficiency metrics. Conventional clustering algorithms reminiscent of KMeans or DBSCAN typically wrestle with parameter sensitivity and dataset variability. Subsequently, a meta-heuristic like ABC, which balances exploration vs exploitation, seems promising.

Observe that in clustering algorithms, parameters ought to technically be known as hyperparameters, as a result of they’re not discovered from the information throughout coaching (as weights in a neural community or regression coefficients are) however they’re set externally. However, for brevity, they’re sometimes called parameters.

Right here’s a concise visible comparability of various clustering algorithms utilized to a number of toy datasets, completely different colours signify completely different clusters that every algorithm discovered for 2D representations:

Within the traditional Iris dataset, the 2 most comparable species — versicolor and virginica — typically pose a problem for clustering algorithms. Many strategies mistakenly group them right into a single cluster, treating them as one steady dense area. In distinction, the extra distinct setosa species is persistently recognized as a separate cluster.

Desk evaluating a number of in style clustering algorithms out there within the scikit‑study library:

Okay‑Means as a Primary Clustering Instance

Okay‑Means is among the many most generally used clustering algorithms, valued for its simplicity and effectivity. Due to its prevalence, I’ll define it right here in additional element as a consultant instance of how clustering is often carried out. Its recognition comes from its simplicity and effectivity, although it does have limitations. A key disadvantage is that the variety of clusters ok have to be specified upfront.

How Okay‑Means Works

1. Initialize Centroids:
   Choose ok beginning centroids, both randomly or with smarter methods like Okay‑Means++, which spreads them out to enhance clustering high quality.
2. Assign Factors to Clusters:
   Characterize every knowledge level as an n-dimensional vector, the place every part corresponds to 1 characteristic. Assign factors to the closest centroid utilizing a distance metric (generally Euclidean). In excessive‑dimensional areas, this step is sophisticated by the Curse of Dimensionality, the place distances lose discriminative energy.
3. Replace Centroids & Repeat:
   Recompute every centroid because the imply of all factors in its cluster, then reassign factors to the closest centroid. Repeat till assignments stabilize — that is convergence.

Sensible Concerns

• Curse of Dimensionality: In very excessive dimensions, distance metrics turn into much less efficient, decreasing clustering reliability. 
• Dimensionality Discount: Methods like PCA or t‑SNE are sometimes utilized earlier than Okay‑Means to simplify the characteristic area and enhance outcomes.
• Selecting Okay: Strategies such because the Elbow Methodology, Silhouette Rating, or meta‑heuristics (e.g., ABC optimization) assist estimate the optimum variety of clusters.

🏋️Health Mannequin for Clustering

The FitnessModel evaluates clustering candidate options on a dataset. The objective of clustering algorithm is to provide clusters that ideally map carefully to the true lessons however normally it’s not an ideal match. ARI (Adjusted Rand Index) is used to measure the similarity between two clusterings (predicted vs. floor fact) – it’s a extensively used metric for evaluating clustering efficiency as a result of it corrects for likelihood settlement, works throughout completely different clustering algorithms, and supplies a transparent scale from −1 to +1 that’s simple to interpret.

Health = 1 – ARI, so decrease health is healthier. This permits ABC to instantly optimize clustering high quality. Proven under is an instance run for the preliminary iterations of an ABC with Gemini Brokers that I developed together with a preview of the LLM uncooked response texts. Observe how the GMM (Gaussian Combination Fashions) steadily improves as new candidates are chosen on every iteration by the completely different bee brokers. Discuss with the Google Colab pocket book for the logs for extra iterations.

Beginning ABC run with Health Mannequin for dataset: Iris

  Options: 4, Courses: 3

  Baseline Fashions (ARI): {'DBSCAN': 0.6309344087637648, 'KMeans': 0.6201351808870379, 'Agglomerative': 0.6153229932145449, 'GMM': 0.5164585360868599, 'Spectral': 0.6451422031981431, 'MeanShift': 0.5681159420289855}

Runner: Initiating Scout Agent for preliminary options...

  Scout Producing preliminary candidate options...

  Scout                 :  Sending immediate to Gemini mannequin... n_candidates=12

  Scout                 :  Acquired response from Gemini mannequin.

  Scout                 : Uncooked response textual content: ```json[{"model":"KMeans","params":{"n_clusters":3,"init":"k-means++","n_init":10,"random_state":42}},{"model":"KMeans","params":{"n_clusters":4,"init":"random","n_init":10,"random_state":42}},{"model":"KMeans","params":{"n_clusters":5,"init":"k-mean...

  Scout                 :  Initial candidates generated.

Runner: Scout Agent returned 12 initial solutions.

Runner: Starting iteration 1/8...

Runner: Agents completed actions for iteration 1.

--- Iteration 1 Details ---

  GMM Candidate 1 (Origin: Scout-10010)   : Best previous ARI=0.820, Current ARI=0.820, Params: {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}

  KMeans Candidate 2 (Origin: Scout-10000): Best previous ARI=0.620, Current ARI=0.620, Params: {'n_clusters': 3, 'init': 'k-means++', 'n_init': 10, 'random_state': 42}

  DBSCAN Candidate 3 (Origin: Scout-10004): Best previous ARI=0.550, Current ARI=0.550, Params: {'eps': 0.7, 'min_samples': 4}

  GMM Candidate 4 (Origin: Scout-10009)   : Best previous ARI=0.820, Current ARI=0.516, Params: {'n_components': 3, 'covariance_type': 'full', 'max_iter': 100, 'random_state': 42}

  KMeans Candidate 5 (Origin: Scout-10001): Best previous ARI=0.620, Current ARI=0.462, Params: {'n_clusters': 4, 'init': 'random', 'n_init': 10, 'random_state': 42}

  DBSCAN Candidate 6 (Origin: Scout-10003): Best previous ARI=0.550, Current ARI=0.442, Params: {'eps': 0.5, 'min_samples': 5}

  KMeans Candidate 7 (Origin: Scout-10002): Best previous ARI=0.620, Current ARI=0.435, Params: {'n_clusters': 5, 'init': 'k-means++', 'n_init': 5, 'random_state': 42}

  DBSCAN Candidate 8 (Origin: Scout-10005): Best previous ARI=0.550, Current ARI=0.234, Params: {'eps': 0.4, 'min_samples': 6}

*** Global Best so far: ARI=0.820, Candidate={'model': 'GMM', 'params': {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}, 'origin_agent': 'Scout-10010', 'current_ari_for_display': 0.8202989638185834}

-----------------------------

Runner: Starting iteration 2/8...

  Scout Generating initial candidate solutions...

  Scout                 :  Sending prompt to Gemini model... n_candidates=12

  Employed Refining current solutions...

  Employed              :  Sending prompt to Gemini model... n_variants=12

  Onlooker Evaluating candidates and selecting promising ones...

  Onlooker              :  Sending prompt to Gemini model... top_k=5

  Scout                 :  Received response from Gemini model.

  Scout                 : Raw response text: ```json[{"model":"KMeans","params":{"n_clusters":3,"init":"k-means++","n_init":10,"random_state":42}},{"model":"KMeans","params":{"n_clusters":4,"init":"random","n_init":10,"random_state":42}},{"model":"KMeans","params":{"n_clusters":5,"init":"k-mean...

  Scout                 :  Initial candidates generated.

  Employed              :  Received response from Gemini model.

  Employed              : Raw response text: ```json[{"model":"GMM","params":{"n_components":5,"covariance_type":"tied","max_iter":100,"random_state":42}},{"model":"GMM","params":{"n_components":3,"covariance_type":"full","max_iter":100,"random_state":42}},{"model":"KMeans","params":{"n_cluster...

  Employed              :  Solutions refined.

  Onlooker              :  Received response from Gemini model.

  Onlooker              : Raw response text: ```json[{"model":"GMM","params":{"n_components":4,"covariance_type":"tied","max_iter":100,"random_state":42}},{"model":"KMeans","params":{"n_clusters":3,"init":"k-means++","n_init":10,"random_state":42}},{"model":"DBSCAN","params":{"eps":0.7,"min_sam...

  Onlooker              :  Promising candidates selected.

Runner: Agents completed actions for iteration 2.

--- Iteration 2 Details ---

  GMM Candidate 1 (Origin: Scout-10022)   : Best previous ARI=0.820, Current ARI=0.820, Params: {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}

  GMM Candidate 2 (Origin: Scout-10010)   : Best previous ARI=0.820, Current ARI=0.820, Params: {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}

  GMM Candidate 3 (Origin: Onlooker-30000): Best previous ARI=0.820, Current ARI=0.820, Params: {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}

  GMM Candidate 4 (Origin: Employed-20007): Best previous ARI=0.820, Current ARI=0.820, Params: {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 80, 'random_state': 42}

  GMM Candidate 5 (Origin: Employed-20006): Best previous ARI=0.820, Current ARI=0.820, Params: {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 120, 'random_state': 42}

  GMM Candidate 6 (Origin: Employed-20000): Best previous ARI=0.820, Current ARI=0.693, Params: {'n_components': 5, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}

  KMeans Candidate 7 (Origin: Scout-10012): Best previous ARI=0.620, Current ARI=0.620, Params: {'n_clusters': 3, 'init': 'k-means++', 'n_init': 10, 'random_state': 42}

  KMeans Candidate 8 (Origin: Scout-10000): Best previous ARI=0.620, Current ARI=0.620, Params: {'n_clusters': 3, 'init': 'k-means++', 'n_init': 10, 'random_state': 42}

*** Global Best so far: ARI=0.820, Candidate={'model': 'GMM', 'params': {'n_components': 4, 'covariance_type': 'tied', 'max_iter': 100, 'random_state': 42}, 'origin_agent': 'Scout-10010', 'current_ari_for_display': 0.8202989638185834}

While the Adjusted Rand Index (ARI) provides a single score for clustering quality, the Confusion Matrix reveals where misclassifications occur by showing how true classes are distributed across predicted clusters.

In the Iris dataset, scikit‑learn encodes the species in a fixed order: 

0 = Setosa, 1 = Versicolor, 2 = Virginica. 

Even though there are only three true species, the algorithm below mistakenly produced four clusters. The matrix illustrates this mismatch:

[[ 0  6 44  0]
[ 2  0  0 48]
[49 0  0  1 ]
[ 0  0  0  0 ]]

⚠️ Observe: The order of the columns (clusters) doesn’t essentially correspond to the order of the rows (true lessons). Cluster IDs are arbitrary labels assigned by the algorithm, they usually don’t carry any inherent that means. 

Row-by-row Interpretation (row and column IDs begin from 0)

• Row 0: [ 0 6 44 0]
  Setosa class → Its samples fall solely into columns 1 and 2, with no overlap with Versicolor or Virginica. These two columns ought to actually have been acknowledged as a single cluster akin to Setosa. 
• Row 1: [ 2 0 0 48]
  Versicolor class → Cut up between columns 0 and 3, exhibiting that the algorithm didn’t isolate Versicolor cleanly.
• Row 2: [49 0 0 1]
  Virginica class → Additionally break up between columns 0 and 3, overlapping with Versicolor relatively than forming its personal distinct cluster.
• Row 3: [ 0 0 0 0]
  Further mistaken cluster → No true samples right here, reflecting that the algorithm produced 4 clusters for a dataset with solely 3 lessons.

📌The confusion matrix exhibits that Setosa is distinct (its clusters don’t overlap with the opposite species), whereas Versicolor and Virginica usually are not separated cleanly – each are unfold throughout the identical two clusters (columns 0 and 3). This overlap highlights the algorithm’s issue in distinguishing between them. The confusion matrix makes these misclassifications seen in a means {that a} single ARI rating can’t.

🏃Working the Agentic AI Loop

The Runner orchestrates iterations:

1. Scout bees suggest numerous options.
2. Employed bees refine them.
3. Onlooker bees choose promising ones.
4. The answer pool is up to date.
5. The most effective ARI per iteration is tracked.

Within the Runner class and all through the Synthetic Bee Colony (ABC) algorithm, a candidate refers to a particular clustering mannequin along with its outlined parameters. Within the instance within the resolution pool proven under, two candidates are returned.

Candidates are orchestrated utilizing python’s concurrent.futures.ThreadPoolExecutor, which permits parallel execution. Because of this, the ScoutAgent, EmployedBeeAgent, and OnlookerBeeAgent are run asynchronously in separate threads throughout every iteration of the algorithm.

The runner.run() technique returns two objects:

solution_pool: This can be a checklist of the pool_size most promising candidates (every being a dictionary containing a mannequin and its parameters) discovered throughout all iterations. This checklist is sorted by health (ARI), so the very first ingredient, solution_pool[0], will signify the best-fitting mannequin and its particular parameters that the ABC algorithm found.

best_history: This can be a checklist that tracks solely the very best Adjusted Rand Index.

For instance:

solution_pool = [

    {

        "model": "KMeans",

        "params": {"n_clusters": 3, "init": "k-means++"},

        "origin_agent": "Employed",

        "current_ari_for_display": 0.742

    },

    {

        "model": "AgglomerativeClustering",

        "params": {"n_clusters": 3, "linkage": "ward"},

        "origin_agent": "Onlooker",

        "current_ari_for_display": 0.715

    }

]

best_history = [

    {"ari": 0.642, "model": "KMeans", "params": {"n_clusters": 3, "init": "random"}},

    {"ari": 0.742, "model": "KMeans", "params": {"n_clusters": 3, "init": "k-means++"}}

]

Answer Pool Setup with ThreadPoolExecutor

ThreadPoolExecutor(): Initializes a pool of employee threads that may execute duties concurrently. 

ex.submit(…): Submits every agent’s act technique as a separate activity to the thread pool.

from concurrent.futures import ThreadPoolExecutor

import copy

# ... inside Runner.run() ...

for it in vary(iterations):

    print(f"Runner: Beginning iteration {it+1}/{iterations}...")

    if it == 0:

        outcomes = []

    else:

        # Use threads as an alternative of processes

        with ThreadPoolExecutor() as ex:

            futures = [

                ex.submit(self.scout.act),

                ex.submit(self.employed.act, solution_pool),

                ex.submit(self.onlooker.act, solution_pool)

            ]

            outcomes = [f.result() for f in futures]

    print(f"Runner: Brokers accomplished actions for iteration {it+1}.")

    # ... remainder of the loop unchanged ...

Every agent’s act technique is dispatched to the thread pool, permitting them to run in parallel. The decision to f.consequence() ensures that the Runner waits for all duties to complete earlier than transferring ahead.

This design achieves two issues:

1. Parallel execution inside an iteration — brokers act concurrently, mimicking actual bee colony habits.
2. Sequential iteration management — the Runner solely advances as soon as all brokers have accomplished their work, conserving the general loop orderly and deterministic.

From the Runner’s perspective, iterations nonetheless seem sequential, however internally every iteration advantages from concurrent execution of agent duties.

Answer Pool Setup with ProcessPoolExecutor

Whereas ThreadPoolExecutor supplies concurrency via threads, it may be seamlessly changed with ProcessPoolExecutor to realize true parallel CPU execution.

With ProcessPoolExecutor, every agent runs in its personal separate course of, which bypasses Python’s GIL (International Interpreter Lock). The GIL is a mutex (mutual exclusion lock) that ensures just one thread executes Python bytecode at a time, even on multi‑core techniques. By utilizing processes as an alternative of threads, heavy numerical workloads can absolutely leverage a number of CPU cores, enabling real parallelism and improved efficiency for compute‑intensive duties.

from concurrent.futures import ProcessPoolExecutor
import copy


# ... inside Runner.run() ...


for it in vary(iterations):
    print(f"Runner: Beginning iteration {it+1}/{iterations}...")


    if it == 0:
        outcomes = []
    else:
        # Use processes as an alternative of threads
        with ProcessPoolExecutor() as ex:
            futures = [
                ex.submit(self.scout.act),
                ex.submit(self.employed.act, solution_pool),
                ex.submit(self.onlooker.act, solution_pool)
            ]
            outcomes = [f.result() for f in futures]


    print(f"Runner: Brokers accomplished actions for iteration {it+1}.")
    # ... remainder of the loop unchanged ...

Key Variations between ProcessPoolExecutor vs ThreadPoolExecutor

• ProcessPoolExecutor launches separate python processes, not threads.
• Every agent runs independently on a unique CPU core.
• This avoids the GIL, so CPU‑sure duties (like clustering, health analysis, numerical optimization) really run in parallel. A CPU‑sure activity is any computation the place the limiting issue is the processor’s velocity relatively than ready for enter/output (I/O).
• Since processes run in separate reminiscence areas, they’ll’t instantly share objects. As an alternative, something handed between them have to be serialized (pickled). Easy python objects like dictionaries, lists, strings, and numbers are picklable, so candidate dictionaries will be exchanged safely.

📌Key Takeaway:

✅ Use ProcessPoolExecutor in case your brokers do heavy computation (matrix ops, clustering, ML coaching). 

❌ Persist with ThreadPoolExecutor in case your brokers are principally I/O‑sure (ready for knowledge, community, disk).

Why are among the candidate parameter values repeated in numerous iterations?

The repetition of candidate parameter values throughout iterations is a pure consequence of how the Synthetic Bee Colony algorithm works and the way the brokers work together:

Scout Bee Agent’s Exploration: The ScoutBeeAgent is tasked with producing new and numerous candidate options. Whereas it goals for variety, given a restricted parameter area or if the generative mannequin finds sure parameter mixtures persistently efficient, it’d counsel comparable options in numerous iterations.

Employed Bee Agent’s Exploitation: The EmployedBeeAgent refines present promising options. If an answer is already superb or near an optimum configuration, the “native neighborhood” exploration (e.g., adjusting parameters by ±10-20%) would possibly lead again to the identical or very comparable parameter values, particularly after rounding or if the parameter changes are small.

Onlooker Bee Agent’s Choice: The OnlookerBeeAgent selects the top_k most promising options from a bigger set of candidates (which incorporates newly scouted, refined by employed, and beforehand promising options). If the algorithm is converging, or if a number of distinct options yield very comparable high-fitness scores, the OnlookerBeeAgent would possibly repeatedly choose parameter units which might be successfully an identical from one iteration to the following.

Answer Pool Administration: The Runner maintains a solution_pool of a set pool_size. It types this pool by health and retains the very best ones. If the highest options stay persistently the identical, or if new good options are an identical to earlier ones, these parameter units will persist and thus be “repeated” within the iteration particulars.

Convergence: Because the ABC algorithm progresses, it’s anticipated to converge in direction of optimum or near-optimal options. This convergence typically signifies that the search area narrows, and brokers repeatedly discover the identical high-performing parameter configurations except some type of pruning technique (like deduplication) is utilized.

📊Reporting Outcomes

Benchmarking Customary Clustering Algorithms

Earlier than making use of ABC, it’s helpful to ascertain a baseline by evaluating the efficiency of normal clustering strategies. I ran a comparability benchmark utilizing default configurations for the next algorithms:

• KMeans
• DBSCAN
• Agglomerative Clustering
• Gaussian Combination Fashions (GMM)
• Spectral Clustering
• MeanShift

As proven within the Google Colab pocket book, the ABC brokers found parameter units that considerably improved the Adjusted Rand Index (ARI), decreasing misclassifications between the carefully associated lessons Versicolor and Virginica.

Reporter Outputs

The Reporter class is answerable for producing last analysis outputs after working the Synthetic Bee Colony (ABC) optimization. It supplies three primary capabilities:

1. Comparability Desk
   • Compares every candidate resolution’s Adjusted Rand Index (ARI) in opposition to baseline clustering fashions.
   • Experiences the development (candidate_ari – baseline_ari).
2. Confusion Matrix Show
   • Prints the confusion matrix of the very best candidate resolution to point out class-level efficiency and misclassifications.
3. Convergence Visualization

• Plots the development of the very best ARI throughout iterations.
• Annotates the plot with mannequin names and parameters for every iteration.

💬Designing Agent Prompts for Gemini

I made a decision to design every agent’s immediate with the next template for a structured strategy:

• Activity Purpose: What the agent should obtain.

• Parameters: Inputs like dataset title, variety of candidates for the agent sort, allowed algorithms and the hyperparameter enter dictionary returned by the WebResearcher through its LLM immediate.

• Constraints: Guarantee every candidate is exclusive, preserve balanced distribution throughout algorithms, require hyperparameters to remain inside legitimate ranges.

• Return Values: JSON checklist of candidate options.

To make sure deterministic LLM habits, I used this generation_config. Particularly, notice that specifying a temperature of zero leaves the mannequin with no room for creativity between prompts and easily repeats the earlier response.

generation_config={

        "temperature": 0.0,

        "top_p": 1.0,

        "top_k": 1,

        "max_output_tokens": 4096

    }

res = genai_model.generate_content(immediate, generation_config=generation_config)

Whereas growing new code like on this venture, you will need to make sure that for a similar enter, you get the identical output.

⚠️Gemini Agentic AI Points

Gemini AI Mannequin Varieties

• Lite (Flash‑Lite): Prioritize velocity and price effectivity. Excellent for bulk duties like translation or classification. 
• Flash: Nicely‑fitted to manufacturing workloads requiring scale and average reasoning.
• Professional: The flagship tier – greatest for advanced reasoning, multimodal comprehension (textual content, pictures, audio, video), and agentic AI use instances.

Why Prompts Alone Fail in Lite Fashions

I bumped into a typical limitation for the “Lite” fashions:
LLMs don’t reliably obey directions like “at all times embrace these parameters” simply since you put them within the immediate. As of as we speak, fashions typically revert to defaults or minimal units except construction is enforced after technology. Why the express immediate nonetheless failed:

• Pure language directions are weak constraints. Even “at all times embrace precisely these parameters” is interpreted probabilistically.
• No schema enforcement. When parsing JSON, you should validate that required keys exist.
• Deduplication addresses duplicates, not gaps. It eliminates an identical candidates however doesn’t restore lacking parameters.

📌Key Takeaway: Prompts alone gained’t assure compliance. You want immediate + schema enforcement to make sure outputs persistently embrace required parameters.

Immediate Compliance Points and Schema Options

Fashions can prioritize different elements of the immediate or simplify outputs regardless of emphasis on required gadgets.

• Instance instruction: “Return Values: ONLY output a JSON-style dictionary. Return string have to be not than 1024 characters.”
• Noticed consequence: len(res_text) = 1036 – responses exceeded the restrict.
• Lacking fields: Required gadgets generally didn’t seem, even when acknowledged clearly. Offering concrete output examples improved adherence.
• Sensible repair: Pair prompts with schema enforcement (e.g., validate required keys, size checks) and publish‑technology normalization to ensure construction.

Empty Candidate Errors in Gemini API

Now and again, I obtained this response:

>> ScoutAgent: Error throughout API name (Try 1/3): Invalid operation: The response.textual content fast accessor requires the response to include a legitimate Half, however none have been returned. The candidate’s finish_reason is 2.

That error message means the mannequin didn’t truly return any usable content material in its response, so when my code tried to entry response.textual content, there was no legitimate “Half” to learn. The important thing clue is finish_reason = 2, which in Google’s API corresponds to a STOP or no content material generated situation (the mannequin terminated with out producing textual content).

Why it occurs:

• Empty candidate: The API name succeeded, however the mannequin produced no output.
• FinishReason = 2: Signifies the technology stopped earlier than yielding a legitimate half.
• Fast accessor failure: Since response.textual content expects at the very least one legitimate textual content half, it throws an error when none exist.

Easy methods to deal with it:

• Examine finish_reason earlier than accessing response.textual content. Solely learn textual content if the candidate features a legitimate half.
• Add fallback logic: If no textual content is returned, log the end motive and retry or deal with gracefully.
• Schema enforcement: Validate that required fields exist within the response earlier than parsing.

📌 Key Takeaway: This isn’t a community error — it’s the mannequin signaling that it stopped with out producing textual content. You will discover the complete checklist of FinishReason values and steerage on deciphering them in Google’s documentation: Generate Content material API – FinishReason.

Intermittent API Connection Errors

Now and again, the Gemini API name failed with:

• Error: ConnectionError: (‘Connection aborted.’, RemoteDisconnected(‘Distant finish closed connection with out response’))

📌 Key Takeaway: This can be a community error and occurred with out code modifications, indicating transient community or service points. Add retries with exponential backoff, timeouts, and strong logging to seize context (request dimension, charge limits, finish_reason) and get well gracefully.

Agent Safety Concerns

Another factor to concentrate to, particularly in case you are utilizing Brokers for company use – safety is mission-critical!

⚠️Present strict guardrails between Brokers and the LLM.  Actively forestall brokers from deleting vital information, taking off‑matter actions, making unauthorized exterior API calls, and so forth.

📌 Key takeaway: Apply the Precept of Least Privilege

• Scope: Prohibit every agent’s permissions strictly to its assigned activity.
• Isolation: Block filesystem writes, exterior calls, or off‑matter actions except explicitly licensed.
• Audit: Report all actions and require approvals for delicate operations.

⚔️Agentic AI Aggressive Panorama in direction of 2026

Mannequin Suppliers

This desk outlines how the agentic AI market is anticipated to develop within the close to future. It highlights the primary corporations, rising rivals, and the developments that may form the area as we transfer in direction of 2026. Offered right here as a non‑exhaustive checklist of direct rivals to Gemini, the purpose is to offer readers a transparent image of the strategic atmosphere during which agentic AI is evolving.

Agent Orchestration Frameworks

This desk examines the administration and orchestration facets of agentic AI. It highlights how completely different frameworks deal with coordination, reliability, and integration to allow scalable agent techniques.

✨Conclusion and Future Work

This venture was my first experiment with Gemini’s agentic AI, adapting the Synthetic Bee Colony algorithm to an optimization activity. Even on a small dataset, it demonstrated how LLMs can tackle bee‑like roles in a meta‑heuristic course of, whereas additionally revealing each the promise and the sensible challenges of this strategy. Be at liberty to repeat and adapt the Google Colab pocket book in your personal initiatives.

Future Work

• Making use of the ABC meta‑heuristic to bigger and extra numerous datasets.
• Extending the WebResearcher agent to robotically assemble datasets from area‑particular sources (e.g. Royal Botanic Gardens Kew – POWO), impressed by Sir Ronald Fisher’s pioneering work in statistical botany.
• Working experiments with expanded swimming pools of employee threads and adjusting the variety of candidates per bee agent sort.
• Exploring semi‑supervised clustering, the place a small labeled dataset enhances a bigger unlabeled one.
• Evaluating outcomes from Google’s Gemini API with outputs from different suppliers’ APIs.