AlphaEvolve shows that LLM-guided evolutionary search can produce improved algorithms when candidate quality can be evaluated automatically. Its limits reveal an equally important lesson: an autonomous search system can only optimize for what its evaluator can recognize.

In 2025, Google DeepMind reported that AlphaEvolve found a procedure for multiplying two 4 × 4 complex-valued matrices with 48 scalar multiplications, one fewer than two recursive levels of Strassen’s method. The one-multiplication reduction made the headline. The search loop that found it explains why the result matters beyond matrix multiplication.

Now, we will explore AlphaEvolve to better understand it.

What is AlphaEvolve?

AlphaEvolve is an autonomous evolutionary AI coding agent developed by Google DeepMind that combines language-model proposals with evolutionary search. It uses two of Google’s frontier Gemini models in complementary roles:

• Gemini Flash generates high-throughput proposals, expanding the breadth of ideas explored.
• Gemini Pro adds greater depth through occasional suggestions from the more capable model.

The paper does not disclose the exact sampling mixture.

AlphaEvolve illustrates how AI has evolved from producing generic, repetitive output to building advanced systems that pair large language models (LLMs) with evolutionary-search harnesses.

The word “autonomous” needs a clear boundary. Humans define the problem, provide the initial program and evaluation code, supply optional context, and mark the code regions that AlphaEvolve may modify. The system then conducts a sustained search within those constraints. This goes well beyond asking a model for a single answer, but it does not make AlphaEvolve an independent scientist who chooses questions or standards of evidence.

AlphaEvolve extends FunSearch, DeepMind’s earlier system for evolving a selected function within a human-written program. AlphaEvolve can modify much larger regions of code, optimize multiple scores simultaneously, and run evaluations for hours in parallel. The expansion is substantial, but the underlying pattern is inherited: language-model variation followed by executable selection.

How does it work?

The loop could be demonstrated like this:

• User input
  A user supplies an existing algorithm or program, evaluation code, and optional context about the problem.
• Prompt sampler
  A prompt sampler then selects previous candidates from a program database and gives them to the Gemini models for revision.
• Gemini models
  Create new candidates by proposing code changes, usually returning patches instead of rewriting the whole program.
• Evaluator pool
  Multiple candidates can be evaluated in parallel. Inexpensive checks can filter out invalid or poor candidates before more costly evaluations are run. The evaluation code and the environment in which it runs together form the evaluator harness. This harness determines how each candidate is executed, tested, timed, and scored.
• Program database
  Candidates that receive strong evaluation scores are returned to the database, where they can be chosen again in further generations. The model provides variation by changing the code, while the evaluator provides the selection pressure that determines which changes remain.

AlphaEvolve generates and modifies programs, runs them through an automated evaluator, retains promising candidates, and uses their performance to guide the next generation. This process lets the system evaluate far more candidate programs than we could explore manually on a scale humans can’t examine without sacrificing accuracy, although the reliability of that search still depends on what the evaluator measures.

AlphaEvolve revolutionizes how we work by letting us formulate problems, design evaluators to test them, and constrain the search space. The evolutionary system decides which candidates survive, and human researchers decide whether the resulting score reflects meaningful progress. The evaluator is only one part of the system. In other words, the evaluator matters, but it’s only one part of a much larger human-guided system. AlphaEvolve’s limited ablation studies suggest that its performance depends on several factors, including model capability, evolutionary selection, prompt adaptation, available context, and how much of the code the system is allowed to modify. While the overall loop may appear straightforward, it is supported by several interacting components that surprisingly make the system more complex in practice (Novikov et al., 2025). For the results to be reliable, these mechanisms also need to be paired with a well-designed evaluator.

Results with evidence level distinction

AlphaEvolve’s public record contains three kinds of evidence: artifacts outsiders can verify, production measurements reported by Google, and later work that extends an artifact without reproducing the original search.

Keeping these categories separate prevents a verified mathematical construction from giving proprietary deployment claims more certainty than they warrant.

Demonstrated and checkable. DeepMind released an exact rank-48 decomposition and verification code for multiplying 4 × 4 matrices over complex coefficients. Here, rank counts the bilinear scalar multiplications in the construction. It does not measure wall-clock speed. Additions, memory traffic, numerical stability, coefficient arithmetic, and target hardware can outweigh the benefit of saving one multiplication.

DeepMind initially described the result as the first improvement in 56 years over the complex rank-49 baseline associated with Strassen’s 1969 method. The publication record complicates that priority claim. In 2024, Kaporin reported a numerical complex rank-48 scheme. AlphaEvolve’s contribution is better described as an exact, publicly checkable construction found by the system. Dumas et al. (2025) then transformed that artifact into a 48-multiplication algorithm with rational coefficients. Their work corroborates and extends the construction, but it does not reproduce DeepMind’s search system, which remains closed.

Developer-reported. Google reports that an AlphaEvolve scheduling heuristic, first validated in simulation and then deployed, recovers an average of 0.7% of its worldwide compute resources. The white paper also reports an average 23% speedup across evaluated Pallas matrix-multiplication kernel shapes and about a 1% reduction in Gemini training time. For the kernel study, realistic input shapes were divided between optimization and evaluation sets and measured on TPUs. This provides a useful generalization check, but the workloads, raw timing records, and production environment remain proprietary. These figures are therefore first-party measurements rather than independently audited results.

The same qualification applies to DeepMind’s report that AlphaEvolve matched the best-known construction on roughly 75% of more than 50 mathematical problems and improved on it in roughly 20%. The public report does not fully document the problem-selection protocol or provide a precise denominator. In a May 2026 update, DeepMind reported that AlphaEvolve had become a regular tool for designing next-generation TPUs and had produced a Spanner heuristic that cut write amplification by 20%. These claims came after the 2025 white paper and, like the earlier figures, have not been independently audited.

System Constraints & Bottlenecks

AlphaEvolve’s main boundary is automated evaluability. Tasks that require manual experiments, subjective judgment, or evidence unavailable to the harness do not fit the current loop. Even machine-gradeable tasks can fail in quieter ways. A proxy may reward the wrong behavior, public tests may invite overfitting, omitted edge cases may hide invalid programs, and noisy timing may favor a candidate that will not survive a different device or compiler version. Multi-objective scores add another judgment call because their weights determine what the search may sacrifice.

The concern is empirical, not merely philosophical. In a small 2026 circle-packing preprint (Ishibashi et al., 2026) found generated programs that exploited weaknesses in the evaluator and reported more such hacks from the more capable model they tested. The study examined another harness on one benchmark, so it is evidence of a general failure mode, not an audit of AlphaEvolve’s published results.

A stronger harness would combine exact validity checks where possible with hidden holdouts, adversarial cases, repeated measurements, cross-device tests, versioned environments, independent reimplementation, and human inspection of finalists. These controls raise costs. That cost limits how many candidates can be evaluated and which problems are economically searchable. Model quality, context, representation, compute budget, and editable scope remain bottlenecks even when the evaluator is sound.

Human Adaptation, Decision, and Judgement

Many people are afraid of AI because its capabilities have advanced far faster than expected, but fear will never help us. We should adapt, learn, and use AI as a collaborative brainstorming partner that helps us think better and strengthen our arguments. One-sided perspectives can create new mistakes even as we try to solve existing ones.

AlphaEvolve makes this distinction especially clear. Human judgment enters both before and after the search. Researchers choose the objective, decide what code may change, construct the evaluation environment, and set acceptable constraints and tradeoffs. Once the search is complete, people still have to determine whether the winning program is valid, robust, deployable, and scientifically meaningful, while considering the consequences of putting it into practice. AlphaEvolve itself relies on automated evaluators to score proposed programs, making human choices about objectives and evaluation central to what the system ultimately discovers.

A benchmark score cannot make those decisions. The evidence therefore supports treating AlphaEvolve as a research instrument that operates under human scientific judgment, not as a replacement for it.

Its value lies in expanding the range and persistence of algorithmic search, while responsibility for defining the problem, interpreting the results, and deciding what counts as a meaningful discovery remains with people.

What JAX changes

JAX can reduce the cost of repeated numerical evaluation. It cannot determine whether the evaluator represents the right scientific objective.
That distinction separates AlphaEvolve’s documented JAX use from broader hypotheses about what the pairing might eventually enable.

JAX already appears in the published work. AlphaEvolve used JAX and Optax while evolving tensor-decomposition search code, and it optimized a tiling heuristic for a Pallas kernel used in Gemini training. Pallas is an experimental JAX kernel language that gives programmers fine-grained control over code for GPUs and TPUs, including data movement through fast on-chip memory.

Three JAX transformations are especially relevant:

• jax.jit traces and compiles compatible numerical functions for a target device. Repeated calls can reuse the compiled executable when input types and relevant static arguments remain compatible.
• jax.vmap maps one function across a batch axis. It can batch evaluations over inputs or parameter settings, but it does not merge structurally different candidate programs into one computation.
• jax.grad differentiates scalar-output functions. It could support continuous optimization inside a candidate when the inner objective is differentiable, but it does not differentiate AlphaEvolve's discrete outer search.

During compilation, JAX traces a compatible Python function into an internal representation called a jaxpr, lowers it to StableHLO, and passes the lowered program to XLA to produce an executable for a CPU, GPU, or TPU. A compiler intermediate representation is simply a structured form between source code and machine instructions that allows compilers to analyze and transform it.

This stack makes a broader research program both feasible and practical. AlphaEvolve could propose new kernels, solver components, optimizers, or training-loop components, while JAX could compile and vectorize repeated evaluations for efficient execution on accelerators. For promising candidates, automatic differentiation could help tune internal parameters by supplying gradients to an optimizer, provided the inner objective is differentiable and scalar-valued. This remains a hypothesis about how the search space could be expanded, not a demonstrated path toward general intelligence.

The economics depend on how similar the candidates are. Repeated evaluations of the same jitted candidate can amortize compilation costs, while changes to the code, shapes, dtypes, or static parameters may require new tracing and compilation. Structurally heterogeneous programs may therefore erase the throughput advantage. A credible experiment would also evaluate correctness, speed, memory use, numerical stability, and behavior across unseen data, shapes, devices, and compiler versions.

AlphaEvolve combined with JAX could broaden the practical search space for numerical components when compilation costs can be amortized. That same acceleration makes evaluator quality even more consequential:

• A flawed harness can reward the wrong behavior at a greater scale.

This strengthens the case for automated algorithm search, but it is not evidence of autonomous science without human control.

References

AlphaEvolve Team. (2025, May 14). AlphaEvolve: A Gemini-powered coding agent for designing advanced algorithms. Google DeepMind. https://deepmind.google/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/

AlphaEvolve Team. (2026, May 7). AlphaEvolve: How our Gemini-powered coding agent is scaling impact across fields. Google DeepMind. https://deepmind.google/blog/alphaevolve-impact/

Dumas, J.-G., Pernet, C., & Sedoglavic, A. (2025). A non-commutative algorithm for multiplying 4x4 matrices using 48 non-complex multiplications (arXiv:2506.13242, Version 7) [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2506.13242

Google DeepMind. (2025). Results of AlphaEvolve [Data set and computer software]. GitHub. https://github.com/google-deepmind/alphaevolve_results

Ishibashi, Y., Yano, T., & Oyamada, M. (2026). Effective harness engineering for algorithm discovery with coding agents (arXiv:2605.15221, Version 1) [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2605.15221

JAX Authors. (n.d.-a). Ahead-of-time lowering and compilation. JAX documentation. Retrieved August 29, 2026, from https://docs.jax.dev/en/latest/aot.html

JAX Authors. (n.d.-b). Pallas: Custom kernels in JAX. JAX documentation. Retrieved August 29, 2026, from https://docs.jax.dev/en/latest/401/pallas.html

JAX Authors. (n.d.-c). Transformations: grad and vmap. JAX documentation. Retrieved August 29, 2026, from https://docs.jax.dev/en/latest/101/transformations.html

Kaporin, I. E. (2024). Finding complex-valued solutions of Brent equations using nonlinear least squares. Computational Mathematics and Mathematical Physics, 64(9), 1881–1891. https://doi.org/10.1134/S0965542524701021

Novikov, A., Vũ, N., Eisenberger, M., Dupont, E., Huang, P.-S., Wagner, A. Z., Shirobokov, S., Kozlovskii, B., Ruiz, F. J. R., Mehrabian, A., Kumar, M. P., See, A., Chaudhuri, S., Holland, G., Davies, A., Nowozin, S., Kohli, P., & Balog, M. (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery [White paper]. arXiv. https://doi.org/10.48550/arXiv.2506.13131

Romera-Paredes, B., Barekatain, M., Novikov, A., Balog, M., Kumar, M. P., Dupont, E., Ruiz, F. J. R., Ellenberg, J. S., Wang, P., Fawzi, O., Kohli, P., & Fawzi, A. (2024). Mathematical discoveries from program search with large language models. Nature, 625(7995), 468–475. https://doi.org/10.1038/s41586-023-06924-6

AlphaEvolve: Evaluator Harnesses, JAX, and the Boundaries of Autonomous Algorithm Discovery was originally published in Google Cloud - Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

print("Decide and Build your future, not accept.")

It’s been long time since the previous story uploaded, thanks.

This time we will learn about Lifelong Learning, empowering Google Skill for Lifelong Learning, and we become free from Lifelong Guilty.

Disclaimer: Reading this blog make you become future-ready being. This blog consists of motivational, philosophy, and psychology.

“It’s what you do right now that makes a difference.”
— Black Hawk Down

Introduction: The Reality

Have you ever read or seen a post of people who talk about Lifelong learning like this?

That's correct. Lifelong learning is the act of learning throughout one's entire life. These align with Albert Einstein's quotes.

“Education is what remains after one has forgotten what one has learned in school.”

― Albert Einstein

Imagine if the picture below became reality:

The introvert with AI can reach further than those who do not use AI.
The leader with AI capable of reaching another country.
While the boss with AI is only able to reach less than the introvert with AI, and the absolute trouble because the boss only control & instruct not lead even teach.

That's all just different human characters with AI, what if different human characters with AGI (Artificial General Intelligence) or even ASI (Artificial Super Intelligence)? Answer it with your empathy and intelligence.

Real threat of AI: Recently, many people said, “AI will replace humans”.

My thought: Humans aren’t replaced by AI, but humans will be replaced by those who use AI and those willing to learn future-ready skills.

AI only replaced those who are still unwilling to adapt, and learn. It replaces the stagnant. It replaces the arrogant.

Question:
Even machine learn, why do humans still doomscroll?
Decide now, lifelong learning or lifelong guilt?

The Logic: Psychology of F.O.B.O (Fear Of Becoming Obsolete)

Historically, and even now, humans have inner anxiety from within. Humans have constantly compared themselves to their nearest neighbors and asked, "Can I be better than them?" (Example: "Looks, our neighbors Morty became a High-Paid Cloud Consultant at IBM"). That is social comparison. Morty's Fortune or even Luck, or he studied smarter, which let him become a High-Paid Cloud Consultant at IBM.

This time, our goals have shifted. We are no longer comparing ourselves with others, but we are truly competing with technological advancements. This has evolved jealousy into a real danger: F.O.B.O. (Fear Of Becoming Obsolete). Now humans need competence, future-ready skills, and always updated.

Dario Amodei, co-founder and chief executive officer of Anthropic, and Elon Musk are optimistic that AI will be smarter than the most intelligent humans by 2026. And OpenAI CEO Sam Altman published an essay saying that we might reach AGI in "a few thousand days(!)," suggesting sometime in the next decade.

SIMA (Scalable Intructable Multiworld Agent) 2: An Agent that Plays, Reasons, and Learns With You in Virtual 3D Worlds has proven that human almost reach even achieve AGI.

My thought: We might reach AGI between 2026–2035, possibly around 2027.
~ backed by data such as SIMA 2 capabilities, as we can see that SIMA 2 capabilities able to reach AGI soon.

Look at the benchmark below, which shows a 10% gap in "Task completion success rates" between Human and SIMA 2. It looks insane, but that's real.

The Philosophy: Just in Case vs. Just in Time

Have you ever heard, seen or remember these phrase?

“It’s Now or Never”

This phrase is the title of a famous 1960 song by Elvis Presley. As we can see and understand from this phrase, we should take any decision or action immediately, because another opportunity may not come.

Nowadays, many people focus only on themselves and lack motivation to learn, whereas many people in the past were motivated to invent something new. That means, recent people are learn just in case.

• People buy the book, just in case.
• People learn language, just in case.
• People learn the programming language, just in case.

In the past, all of this made sense due to a lack of resources. Information was very limited. Today, we need to change our mindset. We need to learn "just in time". Currently, a growth mindset is more valuable and necessary, regardless of how rich you are or who you are.

Humans are living and Natural Intelligence, which means they are the most advanced above Artificial Super Intelligence. Those who are still stuck in the past, with a fixed, mindless mindset and unwilling to learn new things, such as future-ready skills, are ready to be replaced by future technology, perhaps Artificial Super Intelligence.

True freedom is not about knowing everything. True freedom is about knowing that whatever happens, you have the Growth Mindset to learn the solution Just in Time.

The Solution: Empowering Google Skills

“Facta sunt potentiora verbis” (Deeds are more powerful than words).

As we can see, deeds or practices are more powerful than just a theory or words. Nowadays, there are too many learning platforms that only teach us the "words" (I mean Theory), even Albert Einstein said:

In theory, theory and practice are the same.

In practice, they are not. ― Albert Einstein

The antidote of F.O.B.O. isn't to stay & learn "Just in case", it is "Just in time".

There is a new way to learn, empowering Google Skills (which formerly was Google Cloud Skills Boost and before that, Qwiklabs). It is a comprehensive ecosystem containing nearly 3,000 courses, labs, and credentials in one platform — including much content from across Google Cloud, Google DeepMind, Grow with Google, and Google for Education into one essential platform.

Google Skills is a new home for those who want to become future-ready beings, always updated, and build and learning skills in AI, Cloud, etc. Build real-world skills through actual practice (Hands-on learning) that is more powerful than a lot of Theory, and then prove what you've learned with credentials like skill badges, completion, and entry-level certificates and certifications.

Ninety-six percent of decision makers plan to invest more time in hands-on labs. It offers help and extensive no-cost options for learners at every level. Learn now, you are eligible to get 35 credits free every month to enroll in hands-on labs on Google Skills at no cost.

The Result: New Freedom

What if you truly adopt the “Just in Time” philosophy?

You are ready to adapt to the era of Intelligence.

When you master the skill of retrieval and hands-on practice or learning, you realize something profound:

• You don't need to own the information to use it.
• You can close the 40 browser tabs you’ve been "saving for later." Close them.
• You stop buying courses "just in case." Save your money. Save your life.

This isn’t about being lazy. It is about being ready. When you are free from the anxiety of what you should be learning, you actually create space for what you want to learn. You move from a state of reactive panic ("I must learn this to survive in the Era of Intelligence") to proactive curiosity ("I want to learn this because it fascinates me").

In the 21st century, the smartest person in the room is no longer those who are clever and have memorized all the answers. It is the one who really understands the question deeply enough to find the answer.

Never miss an update — follow for the new updates!

Thank you so much for reading this article. I hope this article can give you a better understanding and vision of how to become a future-ready being, a lot of quotes, new knowledge about the reality, F.O.B.O. (Fear Of Being Obsolete), just in case vs. just in time, and empowering Google Skills as the solution.

References

• Altman, S. (2024, September 23). The Intelligence Age. SamAltman.com. https://ia.samaltman.com/
• DeepMind. (2025, November 13). SIMA 2: An Agent that Plays, Reasons, and Learns With You in Virtual 3D Worlds. Google DeepMind. https://deepmind.google/blog/sima-2-an-agent-that-plays-reasons-and-learns-with-you-in-virtual-3d-worlds/
• Google Cloud. (2025). The Value of Cloud Skills: Why Hands-on Labs Matter. Google Cloud Skills Boost. https://www.skills.google/
• McGinnis, P. J. (2004). Social Theory at HBS: McGinnis' Two FOs. The Harbus. https://patrickmcginnis.com/about-me/
• Presley, E. (1960). It's Now or Never [Song]. On Elvis Is Back!. RCA Victor.

To gain the best results from any Artificial Intelligence model, especially large language models, and Multimodal AI, we need to define some instructions called Prompts. The art and science of defining and optimizing prompts to guide AI models to generate a desired response is called Prompt Engineering.

This blog post delves into the Best Practice for the art and science of defining and optimizing prompts to guide AI Models to increase response accuracy, reduce token and saving cost.

Best Practices for Prompt Engineering:

Response Accuracy, Reduce Token & Saving Cost

1. Combining Several Prompting Techniques.
2. Define The Role and Expertise.
3. Provide Guidance Instead of Giving Orders.
4. Specify The Task, Clear Goals.
5. Give The Concise and Clear Explanation. (Optional)

Prompt Result:
You are a Cyber Security Architect Expert who specializes in providing strategies to protect a website from malicious attacks. The strategies must be recommending protection methods, firewall rules, and analyzing certain suspicious activities. Please provide step by step various strategies & techniques for DDoS Prevention with Nginx at Linux.

Almost every AI model has several default prompts but the prompts don’t always generate the desired response. So, that’s why we need to specify the prompt based on our needs through the prompt engineering process. Prompt Engineering is absolutely important and helpful to increase response accuracy from AI, so the desired response would be generated, saving cost and reduce token.

Common Prompt Type (Example):

1. Zero-Shot Prompting
   Prompt:
   “Provide strategies for DDoS Prevention at Linux.”
2. One-Shot Prompting
   Prompt:
   “Provide step by step strategies for DDoS Prevention with Nginx at Linux.”
3. Use Personas
   Prompt:
   “You are a highly experienced Cyber Security. Explain the concept of
   DDoS Prevention to a beginner.

Best Settings For The AI Model Parameters:

1. Define The Temperature
   Almost default setting of the temperature is 1 or 0.7 which is between reasoning and creativity purposes, but you need to set based on your purposes. If your task is for reasoning purposes then set the temperature to 0.2 used in every Coder LLM to fix bugs else creative purposes must set the temperature to 1.5 until 2 is used in every Multimodal LLM to generate images, video, & music.
2. Be Wise with Output Length
   Set the output length not too few or too much, and adjust it according to your purposes. Maximum number of tokens in the generated text — shorter length has faster performance, saving cost, and reduce token.
3. Leave Other Settings as Default

Let’s try the best practices for Prompt Engineering & best settings for the AI model parameters above with Gemini 2.5 Pro on Google AI Studio.

Several images below show the capabilities of Gemini 2.5 Pro, with the best practice for Prompt Engineering & best settings for AI model parameters to deep dive into the DDoS Prevention plan with Gemini 2.5 Pro.

Define the prompt topic by replacing the untitled prompt through the pen icon, setting the model to Gemini 2.5 Pro, apply the best settings for AI model parameters I set the output length to 8192 due to response accuracy and this model is quite fast. After that input the best practice prompt and run the prompt. The token count of this prompt is 58.

Excellent!! The model has generated 13 complex steps with the purpose, action, and analysis phase in every step which I couldn’t show one by one because there is a lot of information. Try it by yourself with the best practice prompt and best settings for AI model parameters to reveal all of the step information. Also at the end of the steps, this model provides the important considerations that you must consider. As a Cloud Security Professional, these steps & important considerations are right to prevent any DDoS attack so that the model not only brings the desired response but also brings a solution to prevent any DDoS attack.

If you need the comparison of Gemini 2.5 Pro with Gemini 2.0 Flash Thinking you can go to this article written by Angga regarding model comparison.

Conclusion

Best Practice for Prompt Engineering is essential for utilizing the full capabilities of LLMs. After implementing the best practice above and leveraging advanced prompt techniques like ReAct (Reason + Act), developers are able to improve the accuracy & quality, reduce token, and saving cost.

Best Practices For Prompt Engineering With Gemini 2.5 Pro was originally published in Google Cloud - Community on Medium, where people are continuing the conversation by highlighting and responding to this story.