Two Arc Pro B60s got XeMaya past a one-card coding timeout

Flash-Next loaded on one B60. With two, it took nearly eight minutes longer to start and passed all 24 coding, extraction and tool-decision attempts.

If you already own an Arc Pro B60, a second card is an expensive way to find out whether a bigger local model can finish your work. We ran the same Flash-Next weights on one card and then two to see what the extra memory changes for coding, document extraction and tool calls.

One B60 loaded the model and answered three short checks, then timed out on the first coding task. Two B60s passed all 24 graded attempts with a median reply time of 4.22 seconds. Loading took nearly eight minutes longer with two cards. If you already have a second card, the matched test below shows how to check whether that tradeoff makes sense for your work.

One card loaded the model, then hit the coding deadline

One B60 loaded the 68 GB model in 5 minutes 44 seconds and passed all three short checks. Those replies took 28 to 43 seconds. The first coding task hit our 90-second client limit, and the collector stopped there. The engine log recorded roughly 62 seconds reading the 151-token prompt before generation. We have no scored one-card answer or one-card results for the remaining cases.

Two cards took longer to get ready. XeMaya filled the expert caches from our hard-drive mirror before serving, taking 13 minutes 38 seconds to report ready. It then returned an answer to the same first coding request in 16.70 seconds. The engine spent about 14 seconds reading the prompt and another three generating the answer.

Same model and tasks, with a 90-second deadline per request
MeasurementOne B60Two B60s
Startup5 min 44 s13 min 38 s
Three short checks3 passed, 27.75–42.60 s3 passed, 1.99–3.18 s
First coding task90 s timeoutPassed in 16.70 s
Graded attemptsNone reached grading24 of 24 passed
Peak sampled VRAM22.48 GiB19.46 and 18.66 GiB

The two-card median was 6.31 seconds for coding, 5.57 for document extraction and 2.78 for tool decisions, with eight attempts in each group. The slowest passing reply took 16.70 seconds and the fastest took 1.26. These times include reading the prompt and streaming the answer. The test covers short synthetic tasks and this storage setup.

The engine's peak resident system memory was about 2.27 GiB on one card and 2.23 GiB on two. That process counter excludes most of the operating system's disk cache. Sampled swap use for the benchmark stayed at zero in both arms.

What we asked Flash-Next to do

Our set contained four small Python fixes, four document extractions and four tool decisions. We sent each case twice at temperature zero, one request at a time, with an 8,192-token context and a 512-token answer limit. The coding answers had to pass their tests, the extracted fields and values had to match exactly, and tool calls had to choose the right action and arguments. A correct answer in one case was to leave the tool alone. The tool tests used simulated actions.

Both layouts used XeMaya 0.1.0-beta.1, a Ryzen 5 5600 with 64 GB of system memory, Ubuntu 24.04.4 and Intel's oneAPI 2026.2.0 runtime. Each B60 has 24 GiB of VRAM. The two Qwen3.8-Flash-Next IQ2_XS files total 68.0 GB. XeMaya keeps frequently used parts of the model, called experts, on the GPUs and lets the operating system cache the rest of the files as they are read. With two cards, the second card handled layers 25 through 47. We kept the model files and generation settings matched. How XeMaya splits layers

The first one-card attempt returned the expected smoke answer and stopped when the client rejected a duplicate token-usage frame. For both reported runs, we omitted the request for an extra usage frame. The client still required a valid finish and the stream's end marker. The first attempt remains in the run record. Pinned server implementation

How to check your own cards

Use a Linux x86-64 machine with glibc 2.38 or newer, Intel's Level Zero driver, Python with venv, and room for the weights, Intel's oneAPI runtime and the 1.54 GB model pack. Check glibc with getconf GNU_LIBC_VERSION. Keep the two verified IQ2_XS shards in a directory that contains only this model. Run these steps from the directory with the archive and its checksum file. The device check should print the Arc cards you intend to use. The catalog should list the model with both shards. Release and checksum file · Pinned Linux install guide · Pinned model files

sha256sum -c SHA256SUMS --ignore-missing
tar -xf xemaya-0.1.0-beta.1-linux-x86_64.tar.xz
cd xemaya-0.1.0-beta.1
./xemaya.sh setup
./xemaya.sh doctor
MODEL_DIR=/absolute/path/to/IQ2_XS
export XEMAYA_HOME="$PWD/local-b60"
./xemaya.sh models "$MODEL_DIR"
FIRST=$(find "$MODEL_DIR" -maxdepth 1 -name "*-00001-of-00002.gguf" -print -quit)
.venv/bin/python tools/iq_pack.py --gguf "$FIRST" --out "$PWD/pack-iq2-xs"

The generated config is in $XEMAYA_HOME/configs/. For this Qwen file, replace its args with the native pack and shard arguments below. Keep both shards in the same storage location for both tests. The second shard also holds the embedding table. On our machine both shards were on a hard-drive mirror.

Set CARDS to 1 or 2 and use the PCI addresses printed by ./xemaya.sh doctor. Set the selector to the corresponding Level Zero device numbers. Run only one server at a time, on a machine where those cards are free. This changes the config in the new local-b60 directory and starts a loopback server.

SECOND="${FIRST%-00001-of-00002.gguf}-00002-of-00002.gguf"
MODEL=xemaya-qwen3.8-flash-next-gsq-rco-iq2-xs
PRIMARY=0000:29:00.0  # replace with the PCI address from doctor
CARDS=1             # use 2 and set SECONDARY for the two-card test
SECONDARY=0000:2d:00.0
python3 - "$FIRST" "$SECOND" "$PRIMARY" "$CARDS" "$SECONDARY" "$MODEL" <<'PY'
import json, os, sys
from pathlib import Path
first, second, primary, cards, secondary, model = sys.argv[1:]
assert all(Path(shard).is_file() for shard in (first, second))
config = Path(os.environ["XEMAYA_HOME"]) / "configs" / (model + ".json")
data = json.loads(config.read_text())
data["args"] = [
    "--native", first, "--native-dense-gguf", first,
    "--native-dense-gguf", second, "--ple-gguf", second,
    "--pack", str(Path("pack-iq2-xs").resolve()), "--max-context", "8192",
    "--expert-profile", str(Path("data/expert-profile.bin").resolve()),
    "--expert-cache", "auto", "--mmap-experts", "--prefill", "auto",
    "--spec", "2", "--suffix-draft", "0", "--kv", "int8",
    "--vram-reserve-mib", "1536",
]
data["gpu_pci"] = primary
for field in ("split_pci", "layer_split"):
    data.pop(field, None)
if cards == "2":
    data["split_pci"] = [secondary]
    data["layer_split"] = "25"
    data["args"] += ["--layer-split", "25", "--split-device", secondary]
config.write_text(json.dumps(data, indent=2) + "\n")
PY
SELECTOR=level_zero:0  # use level_zero:0,1 for the two-card test
ONEAPI_DEVICE_SELECTOR="$SELECTOR" ./xemaya.sh serve "$MODEL" \
  --host 127.0.0.1 --port 8188 --no-api-key

In a second terminal, time the load until the health check says loaded: true, then run a real request. The example below should return 42. Time a few of your own requests after that and check each answer. Stop the first server with Ctrl+C in its terminal before changing the card count.

PORT=8188
curl -fsS --max-time 5 "http://127.0.0.1:$PORT/health" | python3 -m json.tool
curl -fsS --max-time 90 -H "Content-Type: application/json" \
  --data '{"model":"xemaya-qwen3.8-flash-next-gsq-rco-iq2-xs","messages":[{"role":"user","content":"What is 17 plus 25? Reply with the decimal integer only."}],"temperature":0,"max_tokens":32,"reasoning_effort":"none","chat_template_kwargs":{"enable_thinking":false}}' \
  "http://127.0.0.1:$PORT/v1/chat/completions" | python3 -m json.tool

Why the third card slowed a different model

In XeMaya's November 10 development test, regular DeepSeek-V4.1-Flash IQ2_XXS decoded at 14.56 tokens per second on a B70 and B65. Adding a B60 behind the chipset took it to 11.58. That B60 had a slower link, and the extra expert-cache hits did not make up for the time spent on its layers. That was a three-card topology with a different model and software revision. Maintainer's test and hardware details

Download the per-attempt results and resource summary for the exact timings, task verdicts and retained timeout.