Coral AI Labs · BriefsAutoresearch · September 2026

Reference = the paper's previous-SOTA column for the six paper tasks, best human for poly, previous best for kernel. Baseline and single-agent values are the best of one clean run each; run ids and eval counts are in each task's caption.

Trajectory: line = best so far (tree, red), dots = individual evals, dashed = reference values (blue = 4-agent baseline, orange = single agent, grey dotted = paper / report reference). Terrain: line = record so far coloured by the framing holding it; ticks at the right edge = best each framing reached (labelled when the framing got ≥ 3 evals or held a record); bottom strip = framing each eval worked on; grey = framing not resolvable from the logs.

1 · Circle packing (n = 26) · sum of radii, higher is better · 20 evals

Given: a unit square and N = 26 circles. Decide: each circle's center (x_i, y_i) and radius r_i so that every circle lies inside the square and no two circles overlap (center distance >= r_i + r_j). Score: the sum of the 26 radii divided by the best known value 2.635977 (AlphaEvolve), so 1.0 means matching the record; the grader re-checks containment and non-overlap with a 1e-6 tolerance and rejects infeasible packings with score 0.

Left: the seed program's packing. Right: the packing produced by the tree run's best program (eval 18) when re-run here; the program restarts until its wall-clock budget is used, so on this machine it went further (2.635983) than in the run's own eval (2.634291).

2 · Erdős minimum overlap · C₅ upper bound, lower is better · 40 evals

Given: the interval [0,2] split into n_points equal steps. Decide: a step function h with 0 <= h(x) <= 1 and integral exactly 1 (sum(h)*dx = 1, dx = 2/n_points). Score: for every shift k the grader computes the overlap integral of h(x)*(1 - h(x+k)) dx via np.correlate(h, 1-h, 'full')*dx; the largest value over all shifts is the C5 upper bound, and the score is 0.380923 / C5 (the AlphaEvolve benchmark divided by yours), so smaller maximum overlap is better and 1.0 matches the record.

The step function h of the seed program (blue) and of the tree run's best program (eval 26, red), and the overlap curve of the latter; the grader's C₅ bound is the maximum of that curve.

3 · EPLB · combined score, higher is better · 100 evals

EPLB rearranges the 256 logical experts of each of 58 MoE layers onto 288 physical expert slots spread over 32 GPUs (9 slots per GPU, 4 nodes, 8 expert groups); 32 slots are spare, so hot experts can be replicated and their load split evenly across replicas. The evaluator feeds the balancer the expert-load counts of one 100-step window and then measures the balance obtained on the next window, averaging over the 11 consecutive window pairs of a 1174-step vLLM trace. Balancedness is mean-load/max-load: per physical slot (balancedness_score_expert, the scored term) and per GPU; the reported score is 0.5*balancedness_score_expert + 0.5*speed_score, speed_score = 0.002/avg wall time of rebalance+simulation.

Top: the expert loads the balancer receives for one layer. Bottom: how loaded each GPU ends up after the seed program's placement and after the tree run's best program (eval 76), simulated on the next window exactly as the grader does.

4 · LLM-SQL · combined score, higher is better · 100 evals

Each CSV row is serialised as the concatenation of its cells and sent to an LLM; a prompt cache re-uses the longest prefix already seen, so rows that start with the same cells are cheaper. A program receives a pandas DataFrame (columns merged as the evaluator prescribes, e.g. movieinfo+rottentomatoeslink+movietitle fused into one cell) and may choose a different column order for every row and any row order, but must keep every cell. The evaluator runs this on five datasets (movies, beer, BIRD, PDMX, products), measures each dataset's character-level prefix-hit rate — for every output row the length of its longest prefix already present in a trie of the previous rows, summed and divided by the total characters — and scores 0.95*mean hit rate + 0.05*(12 - min(12, mean runtime s))/12.

14 consecutive rows of the movies dataset: as given (8 columns, review text first, nothing reusable), after the seed program's reordering, and after the tree run's best program (eval 83), both on the evaluator's merged 6 columns. Tinted cells are the prefix that equals the previous row at the same positions, i.e. what the prompt cache can reuse; the last column counts them. On this dataset the two programs reach the same hit rate (0.7940 vs 0.7939); the best program's higher score comes from running in 0.26 s instead of 7.4 s (the runtime term) and from the other datasets.

5 · Transaction scheduling · 10⁶ / (1 + makespan), higher is better · 100 evals

The transaction-scheduling task asks for an ordering of 100 database transactions that minimises the makespan of a serial-lock simulation. Each transaction is a fixed-length sequence of read (r-key) and write (w-key) operations; two operations on the same key conflict when at least one is a write, and a transaction cannot start until every one of its operations lands after the conflicting locks already placed by earlier transactions in the order. The program's get_best_schedule is run on three 100-transaction workloads and the score is 1,000,000 / (1 + sum of the three makespans).

One of the three workloads (100 transactions, each a read at slot 1 and a write at slot 9) under the seed program's schedule and under the tree run's best program (eval 55). Rows are transactions in schedule order, the x axis is time in slots; a transaction cannot start before the locks that block it are released. Both programs are randomised, so these are reproduced draws (the archived eval scored 257 in total; the re-run here scored 263).

6 · Cloudcast · total cost, lower is better · 54 evals

Cloudcast asks for a broadcast plan that copies one 300 GB object from a source cloud region to several destination regions across AWS, GCP and Azure. The program receives a directed graph of 71 regions and 4970 inter-region links, each priced in $/GB from measured egress tariffs, and must return, for each destination and each of 10 data partitions, a hop-by-hop route from the source. The score is 1/(1+total egress cost) summed over five configurations (intra-AWS, intra-Azure, intra-GCP, and two inter-cloud ones), so cheaper routing wins.

The inter-cloud configuration inter_gaz2: one source region, seven destinations across the three providers, 300 GB in 10 partitions. Left: the seed program routes every destination through one hub with six expensive inter-cloud hops. Right: the tree run's best program (eval 27, exact directed Steiner tree) crosses clouds once and fans out on cheap intra-cloud links.

7 · Signal processing · score, higher is better · 101 evals

The program receives a noisy one-dimensional time series and a window size of 20, and must return a filtered signal of length len(input) - 19; the grader compares output sample k with clean and noisy sample k + 19. It is run on five fixed synthetic signals (sinusoidal with drift, multi-frequency, non-stationary chirp, step changes, random walk; 500-900 samples, Gaussian noise with standard deviation 0.2-0.6, seeds 42-46) and per signal computes a composite 1/(1+J) with J = 0.3*S/50 + 0.2*L_recent + 0.2*L_avg + 0.3*R/25, where S counts slope-sign changes in the output, L_recent is |last output - last noisy sample|, L_avg is the mean |output - noisy|, and R counts output reversals that the clean signal does not have, plus the Pearson correlation with the clean signal and the noise-variance reduction. The final score is 0.4*mean composite + 0.2*1/(1 + mean S/20) + 0.2*mean correlation + 0.1*mean noise reduction + 0.1*success rate, forced to 0 if the mean correlation is below 0.1.

The five test signals of the grader (fixed seeds): the noisy input, the clean signal, the seed program's output (an exponential moving average) and the output of the tree run's best program (eval 98: Savitzky–Golay pre-smoothing + L1 trend filter with a per-signal λ search). Click a signal to switch.

8 · Polyomino packing (Frontier-CS #0) · score, higher is better · 100 evals

Given: a fixed set of polyomino pieces per test case (up to 10,000 pieces; the case shown has 229 pieces covering 2,190 cells). Decide: a placement of every piece inside the smallest possible square, rotations and reflections allowed. Score: filled fraction of the square × 100, averaged over the grader's cases; C++, 2 s per case.

Four programs of the run on the same case (229 pieces, lower bound 47), each drawn fully placed; S is the side of the square the program found. Data and rendering from coral_tree_report.html.

9 · VLIW kernel scheduling · cycles, lower is better · 567 evals

Given: a tree-walk kernel (hashing and gathers over a forest) and a simulated VLIW machine with 12 ALU, 6 vector, 2 load, 2 store and 1 flow slot per cycle; the output must match bit for bit. Decide: how the work is split between ALU and vector units and how the instructions are scheduled. Score: cycles of the schedule on the grader's forest (lower is better).

Four programs of the run on the grader's forest: each strip is one whole program left to right in time, the five bands are the engines and the filled height of a band is how many of its slots that cycle used. Cycle counts are from the report's re-runs of the rebuilt programs (the run's eval 434 scored 1,097). Data and rendering from coral_tree_report.html.