# LLM4AD_Next: Turning a Problem Description into a Runnable Evolutionary Search Project

> LLM4AD_Next is a Python platform that generates an evaluator, algorithm skeleton, configuration and debugger from a conversational interview, then runs LLM-driven evolutionary search over the generated code. It is powerful scaffolding for heuristic design, but it is an alpha-stage tool that assumes you have API access to a model and a task you can score automatically.

**Optima-CityU/LLM4AD_Next** — A next-generation automatic algorithm design platform, making automated algorithm design more accessible and easier to use

- Repository: https://github.com/Optima-CityU/LLM4AD_Next
- Website: https://llm4ad-next.cn
- Stars: 565 · Forks: 42
- Language: Python
- License: BSD-3-Clause
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/optima-cityu-llm4ad-next

## The configuration tax that LLM4AD_Next is trying to remove

Automated algorithm design with large language models has a well-known shape: you describe a problem, an LLM proposes candidate code, an evaluator scores each candidate, and a search strategy decides which candidates to keep and mutate. The hard part is rarely the idea. It is the plumbing. You need an evaluator that runs untrusted generated code, a prompt template, a population or archive structure, a logging layer, and a way to resume a run that died at generation 40. LLM4AD_Next targets exactly that plumbing. The README frames the goal as destroying the entry barrier: after you create a directory, an interactive terminal generates the evaluator, algorithm skeleton, configuration and debugger for you. The intended user is a researcher or engineer who has a problem they can score and wants to spend their time on the search rather than on the harness. It is not a general code-generation assistant. Every design decision in the repository points at one workflow: problem description in, evolutionary search project out.

## How the chat-to-project pipeline actually works

The mechanism is a conversational consultant that writes files. You run an interactive command, answer questions about your problem, and the tool emits a project directory containing a runnable pipeline. The generated project is then driven by a YAML config, and the search method is selected by a single key. The README gives this example:

```yaml
evolution:
  type: "eoh"  # options include "diverse_island_ga", "island_ga", "eoh", "meoh", "reevo", "mcts_ahd", "dyca"
```

That design separates two concerns that are usually tangled: the problem definition (evaluator plus skeleton) and the search strategy. The README states that EoH, MEoH, ReEvo and MCTS-AHD were migrated to standalone orchestrators, and the method table marks IslandGA, Diverse Island GA, MEoH, DyCA, EoH, ReEvo and MCTS-AHD as having a working orchestrator, with FunSearch, HillClimb, LHNS, LLaMEA, MLES, MOEA/D, NSGA-II, PartEvo and RandSample marked Pending. That table is the most useful page in the repository, because it tells you which of the named methods you can actually run today. A separate layer, Algorithm Design Skills, ships modular skill definitions for coding agents, with EoH, FunSearch, ReEvo, MEoH and MOEA/D listed as available skills. Long-term memory is backed by MindMemOS with global, project and task scopes.

## Installing LLM4AD_Next and generating a first project

The package is published on PyPI as `llm4ad-next` and requires Python 3.12 or newer. The README's quickstart uses `uv`, and the repository ships a `uv.lock`, so the intended path is a `uv`-managed environment. Note that the project depends on `claude-agent-sdk` and `agentscope` as base dependencies, which means a plain sync pulls in an agent runtime whether or not you use the chat flow.

```bash
uv run llm4ad chat
```

That command starts the interactive consultant. According to the README, it interviews you, then generates an evaluator, an algorithm skeleton, a configuration and a debugger. Expect to be asked about your problem rather than about YAML keys; the point of the flow is that you do not hand-write the config. Once the project exists, you run it by pointing the CLI at the generated config. The README documents the run command as:

```bash
llm4ad run <config.yaml>
```

The README does not document a dry-run mode, a rollback of generated files, or a way to preview what the chat will write before it writes it. If you are trying this on an existing repository, do it on a clean branch. The homepage at https://llm4ad-next.cn offers a browser trial of the same problem-to-algorithm workflow if you want to see the output shape before installing anything.

## Where the generated pipeline breaks down

The first constraint is the evaluator. Evolutionary search over generated code is only as good as the function that scores it, and LLM4AD_Next does not remove the need for one. If your problem cannot be scored automatically and cheaply, the platform has nothing to optimize against. The README's featured case, the AlphaEvolve Mathematics Benchmark, is instructive precisely because its cases are numeric and verifiable: the README reports a result of `2.6359830833` for packing 26 circles in a unit square, against a published AlphaEvolve figure of `2.6358627564`. That is a benchmark where a scalar objective exists. Many real engineering problems do not have one. The second constraint is maturity. `pyproject.toml` classifies the project as `Development Status :: 3 - Alpha`, and the README's own method table shows more Pending entries than Available ones. Several named search methods are documented but not implemented as orchestrators. The third is execution risk: generated code is run as part of the search loop, and the README does not describe a sandboxing model. Treat generated candidates as untrusted code and run them in a container. The repository ships a `docker/` directory and the README mentions versioned Docker Hub images aligned with GitHub release tags, which is the safer way to run a loop you did not write.

## LLM4AD_Next versus hand-rolled FunSearch-style loops

The obvious alternative is writing the loop yourself: a prompt template, an executor, a scoring function, and a population of programs, which is what FunSearch-style work amounts to. The difference is where the effort goes. A hand-rolled loop gives you total control over the archive structure, the prompt, the sandbox and the stopping rule, at the cost of writing and maintaining all of it. LLM4AD_Next trades that control for a generated starting point and a config-selected search method. The trade is real in both directions. If your search needs a nonstandard archive, or you want to interleave symbolic and neural components in the loop, the generated skeleton will be in your way. If your need is a standard evolutionary loop over LLM-generated heuristics, and you would rather pick `eoh` or `island_ga` in a YAML file than implement either, the platform saves the weeks that scaffolding normally costs. The repository also exposes a second path that avoids the CLI entirely: Algorithm Design Skills are markdown skill definitions you hand to a coding agent, with a prompt template in the README that points the agent at a `SKILL.md` URL and a task directory. That path suits people who already work inside a coding agent.

## Licence, dependencies and the cost of keeping up

The project is BSD-3-Clause, which is permissive and imposes no copyleft obligation on the code you generate with it. The repository also ships a `THIRD_PARTY_LICENSES.md` and a `third_party/` directory, which is the right instinct: a platform that vendors or wraps other components should make those licences visible. Read that file before shipping anything derived from the bundled third-party code, and note that the model you point the platform at has its own terms, which the BSD licence says nothing about. On upgrade cost, the version in `pyproject.toml` is `1.1.0` while the most recent GitHub release listed is `v1.0.0` dated 2026-07-09, so the packaged version and the tagged release are not the same number. The README's news entries show features landing monthly through 2026, including the memory layer, the migrated search methods and the Diverse Island GA. The last push to the default branch was on 2026-09-10. That pace means config keys and the set of available search methods can shift between releases, so pin your version and read the changelog before upgrading.

## Conclusion

Adopt LLM4AD_Next if you already have a problem with a cheap, deterministic evaluator and you want to skip the boilerplate of wiring an LLM into an evolutionary loop; the chat workflow and the migrated EoH, MEoH, ReEvo, MCTS-AHD, DyCA and IslandGA orchestrators are the parts worth trying first. Do not adopt it if you cannot define a scoring function, if you need a stable API rather than an alpha, or if you are unwilling to send problem descriptions and candidate code to a hosted model. Before committing, verify that `uv run llm4ad chat` produces a project you can actually run end to end on your own evaluator, and check whether the search method you want is marked Available or Pending in the README table.

## FAQ

### What Python version does LLM4AD_Next require?

The package metadata declares `requires-python = ">=3.12"`, and the README badge states Python 3.12 or newer. The `agentscope` dependency requires Python 3.11 or later, which is satisfied by that floor.

### Which search methods can I actually run in LLM4AD_Next today?

The README's method table marks IslandGA, Diverse Island GA, MEoH, DyCA, EoH, ReEvo and MCTS-AHD as having a working orchestrator implementation. FunSearch, HillClimb, LHNS, LLaMEA, MLES, MOEA/D, NSGA-II, PartEvo and RandSample are listed as Pending for implementation.

### Do I need an LLM API key to use LLM4AD_Next?

The platform is built around LLM-driven algorithm design, and the dependency list includes `openai` and `claude-agent-sdk`. The README does not document an offline or local-model mode, so plan on access to a hosted model.

### Can I try LLM4AD_Next without installing anything?

Yes. The README announces an online trial at https://llm4ad-next.cn/ that runs the full problem-to-algorithm workflow in the browser with no local setup.

## Sources

- [License: BSD-3-Clause](https://github.com/Optima-CityU/LLM4AD_Next/blob/main/LICENSE)
- [Optima-CityU/LLM4AD_Next on GitHub](https://github.com/Optima-CityU/LLM4AD_Next)
- [Project website](https://llm4ad-next.cn)
- [README](https://github.com/Optima-CityU/LLM4AD_Next/blob/main/README.md)
- [Releases](https://github.com/Optima-CityU/LLM4AD_Next/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/optima-cityu-llm4ad-next