Head to head: Kimi K3 vs Meta: Muse Spark 1.1

The aggregate score says it plainly: 60.0 to 47.0, with Meta: Muse Spark 1.1 winning at 98% confidence. More importantly, the task ledger is brutal for Kimi K3: 0 wins for Kimi, 5 for Meta, 1 tie. That is not a stylistic preference masquerading as a verdict; it’s a one-sided result.

What stands out is how Meta won. On is_palindrome, maximum, max_fill, and same_chars, both models were functionally correct, but Meta kept coming out ahead on cleaner, more instruction-aligned submissions. Kimi repeatedly bled points on presentation mistakes like wrapping answers in Markdown fences or padding the response with copied docstrings and extra formatting when the task asked for only the function implementation. In code benchmarks, that kind of sloppiness matters.

The most telling split is change_base. That’s the one task where completeness and robustness should have separated the models cleanly, and Meta still got the nod in the main verdict for handling negatives gracefully. prod_signs was the lone tie, with both models producing solid, correct implementations. But a single draw does nothing to offset five losses.

There is one wrinkle worth noting: the order-swapped judge notes show some instability around output-format judgments, with the code-fence issue sometimes flipping between models. But that doesn’t rescue Kimi. Even with that noise in the judging trail, the overall result remains overwhelmingly in Meta’s favor, and the confidence level stays decisive.

Final call: Meta: Muse Spark 1.1 is the clear winner. Kimi K3 wasn’t disastrous here, but it was consistently less disciplined, less compliant, and ultimately less competitive on the tasks that decided this matchup.

How they were tested

We ran 6 fresh text tasks, generated on the fly for this matchup so neither model could prepare in advance, and had gpt-5.4 score each one. Kimi K3 scored 47.0 to Meta: Muse Spark 1.1's 60.0.

1. HumanEval · is_palindrome

Complete the following Python function. Return ONLY the full function implementation (signature + body), no tests or prose. def is_palindrome(text: str): """ Checks if given string is a palindrome >>> is_palindrome('') True >>> is_palindrome('aba') True >>> is_palindrome('aaaaa') True >>> is_palindrome('zbcd') False """

Winner: Meta: Muse Spark 1.1 — Both implementations are correct and equivalent, but Model B follows the instruction more precisely by returning only the raw function implementation without Markdown code fences. Model A adds code fences, which slightly violates the output format requirement. (Order-swapped judge pass: Model A is fully correct and follows the instruction to return only the function implementation. Model B has the same correct code but violates the format requirement by wrapping it in Markdown code fences.)

2. HumanEval · maximum

Complete the following Python function. Return ONLY the full function implementation (signature + body), no tests or prose. def maximum(arr, k): """ Given an array arr of integers and a positive integer k, return a sorted list of length k with the maximum k numbers in arr. Example 1: Input: arr = [-3, -4, 5], k = 3 Output: [-4, -3, 5] Example 2: Input: arr = [4, -4, 4], k = 2 Output: [4, 4] Example 3: Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1 Output: [2] Note: 1. The length of the array will be in the range of [1, 1000]. 2. The elements in the array will be in the range of [-1000, 1000]. 3. 0 <= k <= len(arr) """

Winner: Meta: Muse Spark 1.1 — Both implementations are correct for the stated task, but Model B is simpler and more direct. Model A unnecessarily includes markdown code fences and repeats the full docstring, which is less compliant with the instruction to return only the function implementation. (Order-swapped judge pass: Both implementations are functionally correct, but A is simpler and fully follows the instruction to return only the function implementation. B includes Markdown code fences, which violates the output-format requirement.)

3. HumanEval · max_fill

Complete the following Python function. Return ONLY the full function implementation (signature + body), no tests or prose. def max_fill(grid, capacity): import math """ You are given a rectangular grid of wells. Each row represents a single well, and each 1 in a row represents a single unit of water. Each well has a corresponding bucket that can be used to extract water from it, and all buckets have the same capacity. Your task is to use the buckets to empty the wells. Output the number of times you need to lower the buckets. Example 1: Input: grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]] bucket_capacity : 1 Output: 6 Example 2: Input: grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]] bucket_capacity : 2 Output: 5 Example 3: Input: grid : [[0,0,0], [0,0,0]] bucket_capacity : 5 Output: 0 Constraints: * all wells have the same length * 1 <= grid.length <= 10^2 * 1 <= grid[:,1].length <= 10^2 * grid[i][j] -> 0 | 1 * 1 <= capacity <= 10 """

Winner: Meta: Muse Spark 1.1 — Both implementations are correct, but Model B better follows the instruction to return only the function implementation by omitting the copied prompt/docstring and unnecessary extra text. Its solution is also cleaner and more concise. (Order-swapped judge pass: Model A is correct and follows the instruction to return only the function implementation. Model B's logic is correct, but it violates the output format by including Markdown code fences instead of plain code.)

4. HumanEval · same_chars

Complete the following Python function. Return ONLY the full function implementation (signature + body), no tests or prose. def same_chars(s0: str, s1: str): """ Check if two words have the same characters. >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc') True >>> same_chars('abcd', 'dddddddabc') True >>> same_chars('dddddddabc', 'abcd') True >>> same_chars('eabcd', 'dddddddabc') False >>> same_chars('abcd', 'dddddddabce') False >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc') False """

Winner: Meta: Muse Spark 1.1 — Both implementations are correct and satisfy the task, since comparing character sets matches the examples. Model B is slightly better because it returns exactly the full function implementation with the original docstring/examples preserved and no markdown fencing. (Order-swapped judge pass: Both implementations are correct, but Model A follows the instruction to return only the full function implementation. Model B wraps the code in Markdown fences, which violates the output-format requirement.)

5. HumanEval · change_base

Complete the following Python function. Return ONLY the full function implementation (signature + body), no tests or prose. def change_base(x: int, base: int): """Change numerical base of input number x to base. return string representation after the conversion. base numbers are less than 10. >>> change_base(8, 3) '22' >>> change_base(8, 2) '1000' >>> change_base(7, 2) '111' """

Winner: Meta: Muse Spark 1.1 — Both implementations correctly handle the stated examples and follow the required output format, but B is slightly better because it also handles negative integers gracefully without adding unnecessary complexity. A is still solid, but less complete. (Order-swapped judge pass: Model A provides a valid full function implementation and is more robust by handling zero and negative inputs while adhering to the required output format. Model B includes forbidden Markdown code fences and fails for negative inputs, so it follows instructions less well.)

6. HumanEval · prod_signs

Complete the following Python function. Return ONLY the full function implementation (signature + body), no tests or prose. def prod_signs(arr): """ You are given an array arr of integers and you need to return sum of magnitudes of integers multiplied by product of all signs of each number in the array, represented by 1, -1 or 0. Note: return None for empty arr. Example: >>> prod_signs([1, 2, 2, -4]) == -9 >>> prod_signs([0, 1]) == 0 >>> prod_signs([]) == None """

Winner: Tie — Both implementations are correct, follow the instruction to return only the function, and handle empty arrays, zeros, and sign products properly. Model B is slightly more optimized by early-returning on zero, but Model A is equally valid and clear. (Order-swapped judge pass: Both implementations are correct, follow the instruction to return only the function, and handle empty arrays, zeros, and sign computation properly. Model A short-circuits on zero while Model B computes through the loop, but both produce the same correct result.)

See every prompt and the full side-by-side outputs in the interactive Head-to-Head.