diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/1-set-up-platform.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/1-set-up-platform.md
new file mode 100644
index 0000000000..eb7240b700
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/1-set-up-platform.md
@@ -0,0 +1,197 @@
+---
+title: Set up Google Developer Device Platform
+description: Understand DDP's device catalog, automation, streaming, and agent workflows, then configure the project and connection tools.
+weight: 2
+layout: learningpathall
+---
+
+## About the platform
+
+Google Developer Device Platform (DDP) gives you access to real Android devices through Google Cloud, without buying and maintaining your own device farm. You can try a new feature across different phone models and Android versions, compare its performance, and check how games and other graphics applications look and respond on each device.
+
+Google's [DDP agent skill](https://docs.cloud.google.com/developer-device-platform/agent-skill) lets you describe that work in natural language. Your coding agent can select a device configuration, reserve a phone, connect through Android Debug Bridge (ADB), and install the tools your experiment needs. It handles the commands and connection details while you choose what to test and approve access and spending.
+
+The agent sends experiment commands to the remote phone, where they run on real hardware. It can inspect the screen, interact with your app, and collect screenshots and measurements for you to review.
+
+The Device Catalog helps you or your agent find an available device and confirm streaming support. Device Streaming provides the interactive connection, and Device Run supports automated tests and executables. See the [DDP overview](https://docs.cloud.google.com/developer-device-platform/overview) for more about these capabilities.
+
+You'll prepare your workstation and apply this workflow to a small TinyStories experiment on a remote Pixel 11. The agent checks Arm SVE2 support, compares a CPU baseline with an optimized kernel path, and reports the measured performance.
+
+## Know which tools run where
+
+Your development computer runs the coding agent, Google's DDP skill, and the Google Cloud CLI. Python and ADB keep it connected to the phone, and scrcpy opens the phone's screen in a desktop window. Screenshots, logs, and the final report are saved on your computer.
+
+The remote Pixel does the model work. Inside Termux, an Android terminal environment, the agent downloads llama.cpp and the TinyStories model, builds the code with Clang, checks the phone's Arm features, and runs the benchmark.
+
+## Check and install the local tools
+
+With the Google Cloud CLI already installed, check the other tools in the terminal your coding agent will use:
+
+```bash
+python3 --version
+node --version
+npm --version
+npx --version
+curl --version
+adb version
+```
+
+You need Python 3.10 or later, a supported Node.js LTS release with npm and npx, curl, and Android platform-tools (`adb`). Python runs Google's ADB forwarder, npx installs the agent skill, curl downloads files, and ADB runs commands on the remote phone.
+
+If a command isn't found or the version is too old, use the instructions for your operating system below. Run the installation steps only for the tools you need. A full Android Studio installation or host NDK isn't required.
+
+{{< tabpane-normal >}}
+ {{< tab header="Linux (Ubuntu 26.04)" >}}
+
+Install Python with virtual-environment support, curl, and ADB. Git is used by the Node Version Manager and scrcpy installation steps:
+
+```bash
+sudo apt update
+sudo apt install -y python3 python3-venv curl adb ca-certificates git
+```
+
+If you need Node.js, install [Node Version Manager (nvm)](https://github.com/nvm-sh/nvm#installing-and-updating), load it into this terminal, and install the current LTS release. This also installs npm and npx:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.41.0/install.sh | bash
+export NVM_DIR="$HOME/.nvm"
+. "$NVM_DIR/nvm.sh"
+nvm install --lts
+```
+
+On other Linux distributions, install the equivalent Python, virtual-environment, curl, and ADB packages with your distribution's package manager.
+
+ {{< /tab >}}
+ {{< tab header="macOS" >}}
+
+Use [Homebrew](https://brew.sh/) to install any missing tools. If Homebrew isn't installed, follow its installation instructions first and complete the steps it prints to add `brew` to your `PATH`.
+
+Install Python, Node.js (which includes npm and npx), and curl:
+
+```bash
+brew install python node curl
+```
+
+Install Android platform-tools to provide ADB:
+
+```bash
+brew install --cask android-platform-tools
+```
+
+ {{< /tab >}}
+{{< /tabpane-normal >}}
+
+Repeat the version checks after installation. Each command should print a version and exit successfully. If you installed Node.js with nvm, restart your coding agent from a terminal that can find `node`, `npm`, and `npx`.
+
+DDP's CLI commands use the beta component. Install it before continuing:
+
+```bash
+gcloud components install beta
+```
+
+If your package-managed CLI disables the component manager, follow [Google's component installation instructions](https://docs.cloud.google.com/sdk/docs/components) for your installation method.
+
+## Install scrcpy to view and control the phone
+
+[scrcpy](https://github.com/Genymobile/scrcpy) displays an Android device in a desktop window and lets you control it with your keyboard and mouse. Install it on your development computer before reserving a phone. Use a local desktop session so the viewer can open a window.
+
+{{< tabpane-normal >}}
+ {{< tab header="Linux (Ubuntu 26.04)" >}}
+
+The upstream project marks Ubuntu's packaged scrcpy version as obsolete. The following commands build scrcpy 5.0.1 using its [upstream Linux installation procedure](https://github.com/Genymobile/scrcpy/blob/v5.0.1/doc/linux.md). These commands use Ubuntu 26.04, which provides the required SDL3 packages for Arm64 and x86-64 hosts. For another distribution or release, follow the upstream instructions for its dependencies.
+
+Install the viewer's runtime and build dependencies:
+
+```bash
+sudo apt update
+sudo apt install -y ffmpeg libsdl3-0 adb wget va-driver-all \
+ gcc git pkg-config meson ninja-build libsdl3-dev \
+ libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev \
+ libswresample-dev libusb-1.0-0 libusb-1.0-0-dev libv4l-dev libdrm-dev
+```
+
+Clone the release into a dedicated directory and run its installer. The script downloads and verifies a prebuilt Android server, builds the desktop client, and uses `sudo` to install it:
+
+```bash
+mkdir -p "$HOME/ddp-tools"
+git clone --branch v5.0.1 --depth 1 https://github.com/Genymobile/scrcpy.git "$HOME/ddp-tools/scrcpy"
+cd "$HOME/ddp-tools/scrcpy"
+./install_release.sh
+```
+
+ {{< /tab >}}
+ {{< tab header="macOS" >}}
+
+Install the viewer using the [upstream Homebrew instructions](https://github.com/Genymobile/scrcpy/blob/master/doc/macos.md). It uses the ADB installation from the previous section:
+
+```bash
+brew install scrcpy
+```
+
+ {{< /tab >}}
+{{< /tabpane-normal >}}
+
+Confirm that the viewer is available:
+
+```bash
+scrcpy --version
+```
+
+You'll open the viewer after the agent connects to the reserved phone and returns its ADB serial.
+
+## Create the agent workspace
+
+Create a directory for the agent and evidence:
+
+```bash
+mkdir -p "$HOME/ddp-first-device/results"
+cd "$HOME/ddp-first-device"
+```
+
+For a concrete agent example, use [Google Antigravity](/install-guides/antigravity/), which is named in [Google's DDP agent documentation](https://docs.cloud.google.com/developer-device-platform/agent-skill). Start it in this directory so the agent can run the local tools, install the project skill, and save screenshots and reports under `results/`.
+
+## Prepare the Google Cloud project
+
+Using the Google account associated with your CLI setup, open the [Google Cloud console](https://console.cloud.google.com/) and select a development project with billing enabled.
+
+{{% notice Note %}}
+DDP Device Streaming requires project access beyond signing in to Google Cloud. Before reserving a phone, confirm that your account has the roles in [Google's DDP quickstart](https://docs.cloud.google.com/developer-device-platform/quickstart#required-roles): Viewer, Device Run Admin, Device Streaming Admin, and Service Usage Consumer, or equivalent permissions supplied by your administrator. Device Streaming sessions incur charges; review the current price before approving a reservation.
+{{% /notice %}}
+
+Enabling APIs also requires `serviceusage.services.enable`, for example through Service Usage Admin. Having permission to view a project doesn't establish permission to reserve a device or edit IAM.
+
+In your workspace terminal, replace the example project ID:
+
+```bash
+export PROJECT_ID="YOUR_PROJECT_ID"
+gcloud auth login
+gcloud config set project "$PROJECT_ID"
+gcloud auth application-default login
+gcloud auth application-default set-quota-project "$PROJECT_ID"
+```
+
+Complete the sign-in and consent steps yourself. The CLI uses its signed-in account for catalog requests. Google's Python streaming client uses Application Default Credentials (ADC), which are configured separately. Use the intended account for both.
+
+Enable the services required by the quickstart:
+
+```bash
+gcloud services enable \
+ devicerun.googleapis.com \
+ devicestreaming.googleapis.com \
+ testing.googleapis.com \
+ --project="$PROJECT_ID"
+```
+
+The command waits for API activation to finish. On success, the output is similar to:
+
+```output
+Operation "operations/OPERATION_ID" finished successfully.
+```
+
+The operation ID varies. If the APIs are already enabled, the command can return successfully without printing a message. You'll confirm the enabled-service list on the next page.
+
+The Cloud Testing API is required by Device Streaming during Preview. If your organization manages API activation centrally, ask the administrator to enable them.
+
+## What you've accomplished and what's next
+
+You've identified DDP's capabilities, prepared the workstation tools, and configured a Google Cloud project and credentials. Next, you'll verify that the CLI can reach the platform and inspect a device configuration without reserving it.
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/2-verify-cli.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/2-verify-cli.md
new file mode 100644
index 0000000000..dc851bb010
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/2-verify-cli.md
@@ -0,0 +1,71 @@
+---
+title: Verify the CLI and discover a remote device
+description: Check your Google Cloud identity, project, credentials, and enabled services, then find the Pixel 11 configuration for your device session.
+weight: 3
+layout: learningpathall
+---
+
+## Verify the account, project, and ADC
+
+In the workspace terminal from setup, check the active account, project, and Application Default Credentials (ADC):
+
+```bash
+gcloud auth list --filter=status:ACTIVE --format='value(account)'
+gcloud config get-value project
+gcloud auth application-default print-access-token >/dev/null
+```
+
+Check that the first two commands show your intended account and project. The final command should exit successfully; its output is deliberately discarded so an access token doesn't appear in your terminal or screenshots. This checks that ADC can obtain a token, rather than just that a credential file exists.
+
+CLI authentication, ADC authentication, and project permissions are separate checks. Successful sign-in doesn't grant new roles.
+
+## Verify the enabled services
+
+List the APIs enabled in your project:
+
+```bash
+gcloud services list --enabled --project="$PROJECT_ID" \
+ --format='value(config.name)'
+```
+
+The output must include `devicerun.googleapis.com`, `devicestreaming.googleapis.com`, and `testing.googleapis.com`. Other enabled APIs can also appear.
+
+## Find the Pixel 11 configuration
+
+Query the device catalog and filter the results to Pixel 11. Select a few fields to keep the output readable:
+
+```bash
+gcloud beta device-run devices list \
+ --project="$PROJECT_ID" \
+ --filter='displayName~"^Pixel 11$"' \
+ --format='table(name.segment(-1):label=ID,displayName:label=NAME,modelCode:label=MODEL,hardwareType:label=HARDWARE_TYPE,products():label=PRODUCTS)'
+```
+
+The output is similar to:
+
+```output
+ID NAME MODEL HARDWARE_TYPE PRODUCTS
+cubs-37 Pixel 11 cubs PHYSICAL Automation, Streaming
+```
+
+This example identifies a physical Pixel 11 with model code `cubs` and streaming support. On the next page, the agent looks up the current configuration for you, so you don't need to copy catalog IDs or Android API levels into your prompt. Catalog results can change; if no row appears, remove `--filter` to inspect other configurations and review an alternative with your agent.
+
+Use the [interactive device catalog](https://docs.cloud.google.com/developer-device-platform/device-catalog) to inspect the same information visually. The example below shows **Pixel 11**, model `cubs`, API level `37`, with physical hardware and streaming support:
+
+
+
+Inspect that entry from the CLI if it's currently available:
+
+```bash
+gcloud beta device-run devices describe cubs-37 \
+ --project="$PROJECT_ID" --format=json > results/device-catalog.json
+python3 -m json.tool results/device-catalog.json
+```
+
+The catalog ID is `cubs-37`; the session request uses model code `cubs` and API level `37` separately. The CLI description can omit the OS version, so retain the catalog's OS value too. Check that the entry includes `arm64-v8a` and `DEVICE_STREAMING`. Availability and supported configurations can change.
+
+The catalog helps you select a device and OS configuration. After connecting, the agent also checks the Arm features available to applications, including SVE2, before choosing the model's optimized kernel path. Keep the catalog selection, runtime feature check, and kernel execution check as separate observations in the report.
+
+## What you've accomplished and what's next
+
+You've checked authentication, project configuration, service activation, and catalog access, and identified the Pixel 11 configuration. Next, you'll give these working tools to the agent and have it connect to the chosen phone.
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md
new file mode 100644
index 0000000000..45320a1d97
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md
@@ -0,0 +1,66 @@
+---
+title: Ask the agent to connect to a phone
+description: Install Google's DDP skill, describe the phone you want, approve the cost, and let the agent connect and display its screen.
+weight: 4
+layout: learningpathall
+---
+
+## Install the DDP agent skill
+
+In the workspace from platform setup, install the skill from [Google's DDP agent documentation](https://docs.cloud.google.com/developer-device-platform/agent-skill):
+
+```bash
+npx skills add https://github.com/google/skills --skill developer-device-platform-basics
+```
+
+Choose your coding agent and a project-local installation. Start a fresh agent session in this workspace so it discovers the skill, and confirm that `developer-device-platform-basics` appears among its available skills.
+
+The skill teaches the agent how to find and reserve a device, manage the session, and establish the connection. You can now describe the phone you want in natural language.
+
+## Ask for a phone and its screen
+
+With your agent using the Google Cloud project you verified on the previous page, give it this prompt:
+
+```text
+Use the DDP skill and my configured Google Cloud project to connect
+to a Pixel 11 with the latest stable Android version available.
+Keep the session within 20 minutes and US$3, ask me to approve the
+cost, and show me the phone's screen with scrcpy.
+```
+
+The agent can look up the current device configuration, check availability, and prepare the connection. You don't need to translate your request into catalog IDs, Android API levels, or connection commands. If the requested phone or Android version isn't available, the agent should explain the options before reserving an alternative.
+
+{{% notice Note %}}
+As with all prompts, you may need to provide more details depending on the agent you're using. The reference experiment in this Learning Path used GPT-6.1 Sol in High mode. Other agents and reasoning settings haven't been tested. Describe any missing behavior or error to your agent so it can investigate.
+{{% /notice %}}
+
+## Approve the reservation
+
+The DDP skill asks for explicit approval before creating a billable session. Review the project, phone, Android version, duration, and estimated cost that the agent proposes. Check [Google's current DDP price](https://cloud.google.com/products/developer-device-platform#pricing), then answer the agent's approval question. If the proposed session would exceed your budget, reduce the duration before approving it.
+
+Keep the approval to one session within the prompt's limits. The agent should set the expiration, connect to the reserved phone, and report when the session ends. Complete any sign-in or consent steps yourself.
+
+The agent handles the reservation and connection through Google's DDP skill. Keep it running while you use the phone.
+
+## Try the connected phone
+
+The scrcpy window should show the reserved phone's current screen. Check that the agent's reported model and Android version match the reservation you approved.
+
+Click to tap, drag to swipe, and use your keyboard to type into a text field. Try opening the app drawer and returning to the home screen. The agent can also save and inspect a screenshot through the same connection:
+
+
+Inspect a real screenshot from the reserved phone
+
+If the screen doesn't appear or control doesn't work, describe what happened to the agent. It can inspect the connection, correct the viewer settings, and try again within the existing session. You can review its observations without managing ports or issuing device commands yourself.
+
+## See what the agent handled
+
+Your request gave the agent a device, an outcome, and spending limits. It translated that into device discovery, a reservation, a connection, and a working screen. Its report should include the session expiration and the location of a saved screenshot, along with enough device information to confirm that it connected to the phone you approved.
+
+Keep the same agent conversation open for the TinyStories experiment on the next page. The agent will use this connection to install the tools, choose compatible Arm optimizations, measure their effect, and release the phone.
+
+If you stop here, ask the agent to release this session and confirm that it has ended. Closing the viewer alone doesn't release the reservation.
+
+## What you've accomplished and what's next
+
+You've installed the DDP skill, requested a phone in natural language, approved its cost, and interacted with the remote device. Next, you'll describe an Arm performance experiment and let the agent handle its setup and measurements.
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/4-benchmark-tinystories.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/4-benchmark-tinystories.md
new file mode 100644
index 0000000000..7a7f5827c0
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/4-benchmark-tinystories.md
@@ -0,0 +1,60 @@
+---
+title: Ask the agent to benchmark TinyStories
+description: Describe a TinyStories CPU comparison in natural language and let the agent select stable tools, verify Arm optimizations, report uplift, and release the phone.
+weight: 5
+layout: learningpathall
+---
+
+## Ask for an Arm performance comparison
+
+Use the connected phone to explore how Arm optimizations affect a small language model's inference performance. TinyStories keeps the experiment small enough to build and run on the phone inside Termux, an Android terminal environment. KleidiAI provides optimized Arm CPU kernels that llama.cpp can use for inference.
+
+Continue in the same agent conversation and give it the second prompt:
+
+```text
+On our DDP phone, compare a small TinyStories model's CPU inference
+with and without Arm KleidiAI optimizations using the latest stable
+Termux and llama.cpp releases. Check output agreement and which Arm
+kernels actually run, including SVE/SVE2 where usable. Repeat with
+the same model and settings, and report prompt-processing and
+token-generation uplift. Save the results locally and release the
+phone within our approved limits.
+```
+
+The prompt gives the agent the workload, comparison, and expected result. It can choose compatible software and model files, prepare the phone, and collect the measurements. You can use it after the connection prompt without attaching these pages or copying version numbers and build settings into the conversation.
+
+## Let the agent prepare and run the experiment
+
+The agent should obtain the latest stable releases from the official [Termux releases](https://github.com/termux/termux-app/releases/latest) and [llama.cpp releases](https://github.com/ggml-org/llama.cpp/releases/latest), then install the tools and build and run the workload on the phone. It records the versions it selected in the saved report so you can revisit the experiment later.
+
+The Arm feature check is part of that work. The agent needs to establish which optimizations the phone exposes, which ones the selected model and runtime can use, and which kernels actually execute. If SVE or SVE2 isn't usable for that combination, it should explain the reason and identify the compatible path it measured.
+
+For a fair comparison, the agent should keep the model, quantization, inputs, thread count, and CPU placement the same, with GPU offload disabled. It should check output agreement before timing and use repeated, warmed-up measurements. You can review the resulting comparison without choosing compiler flags, kernel dispatch settings, or numerical tolerances yourself.
+
+## Review the performance report
+
+Look for separate results for prompt processing and token generation. The report should show the baseline and optimized throughput, the uplift, and the variation across measurements. Check the agent's explanation of the kernels responsible for the result, including any fallback or regression.
+
+The following reference results were measured on November 5, 2026, on a physical Pixel 11 with Tensor G6 and Android 17 (API 37). Each value is the median of five alternating measurement pairs, using the same TinyStories Q4_0 model and one CPU thread:
+
+| Workload | CPU baseline, tokens/s | KleidiAI, tokens/s | Speedup | Throughput uplift |
+| --- | ---: | ---: | ---: | ---: |
+| Prompt processing, 64 tokens | 4,833.49 | 9,925.77 | 2.05× | +105.4% |
+| Token generation, 32 tokens | 1,029.68 | 1,375.95 | 1.34× | +33.6% |
+
+Higher tokens per second is better. Calculate `speedup = optimized / baseline` and `throughput uplift (%) = 100 × (speedup − 1)` from the median throughput for each path. These results measure warmed-up inference and exclude model loading and initial weight packing.
+
+{{% notice Note %}}
+Your agent selects the latest stable releases and a compatible model for your run, so its results can differ.
+{{% /notice %}}
+
+
+## Confirm the results are saved and the phone is released
+
+The prompt includes saving the results and releasing the phone. Check that the agent gives you a readable local report with the measurements, device details, software versions, and kernel evidence.
+
+The agent should cancel the recorded DDP session, confirm that its cloud state is `FINISHED` or `EXPIRED`, and close the viewer and connection. Closing a window alone doesn't stop device-time billing. If the task stops early, ask the agent to release the session and verify that it has ended.
+
+## What you've accomplished
+
+You've used natural language to connect to remote Arm hardware and investigate a performance question. The agent handled device access, software selection, setup, kernel checks, measurement, and cleanup. You chose the task and spending limits, then reviewed the screen, results, and explanation.
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/_index.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/_index.md
new file mode 100644
index 0000000000..856c3e3a58
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/_index.md
@@ -0,0 +1,68 @@
+---
+title: Use Google Developer Device Platform with an AI agent
+
+draft: true
+cascade:
+ draft: true
+
+description: Set up Google Developer Device Platform, verify CLI access, and direct an AI agent to explore Arm SVE2 and TinyStories performance on a remote Pixel phone.
+
+minutes_to_complete: 45
+
+who_is_this_for: Developers who want to access remote Android hardware through Google Cloud and direct a coding agent to inspect and use a real Arm-based phone.
+
+learning_objectives:
+ - Configure a Google Cloud project and local tools for Developer Device Platform
+ - Verify CLI authentication, enabled services, and device catalog access
+ - Use Google's agent skill to discover, reserve, inspect, and release a remote phone
+ - Direct an on-phone TinyStories experiment with runtime feature checks and a measured performance report
+
+prerequisites:
+ - A development machine with a terminal and internet access
+ - The [Google Cloud CLI](/install-guides/gcloud/) and permission to install its beta commands
+ - A coding agent that supports Agent Skills and can run local commands and inspect screenshots, such as [Google Antigravity](/install-guides/antigravity/)
+
+author: Annie Tallund
+
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
+
+skilllevels: Introductory
+subjects: ML
+armips:
+ - Arm C1
+tools_software_languages:
+ - Google Cloud
+ - Agent Skills
+ - Android
+ - llama.cpp
+operatingsystems:
+ - Android
+
+further_reading:
+ - resource:
+ title: Google Developer Device Platform overview
+ link: https://docs.cloud.google.com/developer-device-platform/overview
+ type: documentation
+ - resource:
+ title: Google Developer Device Platform quickstart
+ link: https://docs.cloud.google.com/developer-device-platform/quickstart
+ type: documentation
+ - resource:
+ title: Google's Developer Device Platform agent skill
+ link: https://docs.cloud.google.com/developer-device-platform/agent-skill
+ type: documentation
+ - resource:
+ title: llama.cpp build instructions and KleidiAI support
+ link: https://github.com/ggml-org/llama.cpp/blob/master/docs/build.md
+ type: documentation
+ - resource:
+ title: Termux installation instructions
+ link: https://github.com/termux/termux-app#installation
+ type: documentation
+### FIXED, DO NOT MODIFY
+weight: 1
+layout: learningpathall
+learning_path_main_page: "yes"
+---
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/_next-steps.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/_next-steps.md
new file mode 100644
index 0000000000..e20dfa6d43
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/_next-steps.md
@@ -0,0 +1,8 @@
+---
+# ================================================================================
+# FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21
+title: "Next Steps"
+layout: "learningpathall"
+---
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/files/benchmark-results-2026-11-05.json b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/files/benchmark-results-2026-11-05.json
new file mode 100644
index 0000000000..cfd1eda314
--- /dev/null
+++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/files/benchmark-results-2026-11-05.json
@@ -0,0 +1,1367 @@
+{
+ "measured_date": "2026-11-05",
+ "agent_context": {
+ "model_and_reasoning_reported_by_user": "GPT-6.1 Sol, High",
+ "connection_prompt": "Connect to a DDP Pixel 11 (API 37) and show its screen.",
+ "benchmark_prompt": "Compare TinyStories CPU performance with and without KleidiAI.",
+ "required_context": "Both Learning Path pages, installed Google DDP skill, configured Google Cloud project.",
+ "validation_scope": "Workflow exercised in an ongoing agent session with existing Learning Path context and reused verification scripts. No isolated fresh-agent prompt trial or cross-agent evaluation was performed."
+ },
+ "device": {
+ "ro.product.model": "Pixel 11",
+ "ro.build.version.sdk": "37",
+ "ro.product.cpu.abi": "arm64-v8a",
+ "ro.soc.model": "Tensor G6",
+ "ro.build.fingerprint": "google/cubs/cubs:17/CD1A.260714.001.A9/15938155:user/release-keys",
+ "ro.build.version.security_patch": "2026-08-05"
+ },
+ "runtime_probe": [
+ "HWCAP=0xffffffff HWCAP2=0x5008801af3ff DOTPROD=1 I8MM=1 SVE=1 SVE2=1 SME=0 SME2=0",
+ "SVE_VL_BYTES=16"
+ ],
+ "cpu_affinity": [
+ "Allowed CPUs: 0-6",
+ "Selected CPU: 6",
+ "CPU mask: 40",
+ "Threads: 1",
+ "Cpus_allowed_list:\t6"
+ ],
+ "llama_cpp_revision": "45b6604b20f17b7d7638042306c0cd1b6af5999c",
+ "google_ddp_skill_revision": "f70aa02c5e8d1360169af143f4bfc0af68d73012",
+ "google_ddp_skill_version": "0.5.1",
+ "toolchain": {
+ "clang": "clang version 21.1.8\nTarget: aarch64-unknown-linux-android24\nThread model: posix\nInstalledDir: /data/data/com.termux/files/usr/bin",
+ "cmake": "cmake version 4.4.5\n\nCMake suite maintained and supported by Kitware (kitware.com/cmake).",
+ "ninja": "1.13.2"
+ },
+ "build_options": {
+ "CMAKE_BUILD_TYPE": "Release",
+ "GGML_CPU_KLEIDIAI": "ON",
+ "GGML_CPU_REPACK": "OFF",
+ "GGML_NATIVE": "OFF",
+ "GGML_CPU_ARM_ARCH": "armv8.2-a+dotprod+i8mm",
+ "GGML_OPENMP": "OFF",
+ "GGML_VULKAN": "OFF",
+ "GGML_BLAS": "OFF"
+ },
+ "download_checksums": [
+ "ead3e8b4bc3b1d502a40a6d45e0a6d54b702a0ad99b68f2e49920066ea577e3b source.tar.gz",
+ "66967fbece6dbe97886593fdbb73589584927e29119ec31f08090732d1861739 stories15M-q4_0.gguf"
+ ],
+ "method": {
+ "thread_count": 1,
+ "cpu": 6,
+ "gpu_layers": 0,
+ "prompt_tokens": 64,
+ "generated_tokens": 32,
+ "batch": 64,
+ "microbatch": 64,
+ "pairs": 5,
+ "pair_order": [
+ "baseline,kleidiai",
+ "kleidiai,baseline",
+ "baseline,kleidiai",
+ "kleidiai,baseline",
+ "baseline,kleidiai"
+ ],
+ "warmup": true,
+ "statistic": "median of five individual throughput measurements per path",
+ "timing_excludes": [
+ "model loading",
+ "initial weight packing"
+ ],
+ "comparison": "One binary, same model and settings, --repack 0 vs --repack 1; baseline retains normal Arm CPU optimizations."
+ },
+ "summary": {
+ "runs_per_mode": 5,
+ "threads": 1,
+ "comparison": "llama.cpp CPU baseline vs Arm KleidiAI extra buffers; baseline retains normal Arm CPU optimizations",
+ "results": [
+ {
+ "test": "pp64",
+ "baseline_samples_tps": [
+ 4833.49479,
+ 4684.063914,
+ 4666.494736,
+ 5110.556509,
+ 5130.8281
+ ],
+ "kleidiai_samples_tps": [
+ 9457.073825,
+ 9237.500615,
+ 9925.766126,
+ 10168.524223,
+ 10373.121168
+ ],
+ "baseline_median_tps": 4833.49479,
+ "kleidiai_median_tps": 9925.766126,
+ "baseline_range_tps": [
+ 4666.494736,
+ 5130.8281
+ ],
+ "kleidiai_range_tps": [
+ 9237.500615,
+ 10373.121168
+ ],
+ "speedup": 2.05353818660059,
+ "throughput_uplift_percent": 105.35381866005902,
+ "time_reduction_percent": 51.303559557595
+ },
+ {
+ "test": "tg32",
+ "baseline_samples_tps": [
+ 1026.824606,
+ 1029.677792,
+ 1014.977419,
+ 1083.263234,
+ 1075.056226
+ ],
+ "kleidiai_samples_tps": [
+ 1342.269267,
+ 1363.344348,
+ 1540.356102,
+ 1375.954203,
+ 1500.151984
+ ],
+ "baseline_median_tps": 1029.677792,
+ "kleidiai_median_tps": 1375.954203,
+ "baseline_range_tps": [
+ 1014.977419,
+ 1083.263234
+ ],
+ "kleidiai_range_tps": [
+ 1342.269267,
+ 1540.356102
+ ],
+ "speedup": 1.3362958914821386,
+ "throughput_uplift_percent": 33.62958914821385,
+ "time_reduction_percent": 25.166274447580584
+ }
+ ]
+ },
+ "raw_measurements": [
+ {
+ "pair": 1,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:14Z",
+ "avg_ns": 13240937,
+ "stddev_ns": 0,
+ "avg_ts": 4833.49479,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 13240937
+ ],
+ "samples_ts": [
+ 4833.49
+ ]
+ }
+ },
+ {
+ "pair": 1,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:14Z",
+ "avg_ns": 31164037,
+ "stddev_ns": 0,
+ "avg_ts": 1026.824606,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 31164037
+ ],
+ "samples_ts": [
+ 1026.82
+ ]
+ }
+ },
+ {
+ "pair": 1,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:16Z",
+ "avg_ns": 6767421,
+ "stddev_ns": 0,
+ "avg_ts": 9457.073825,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 6767421
+ ],
+ "samples_ts": [
+ 9457.07
+ ]
+ }
+ },
+ {
+ "pair": 1,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:16Z",
+ "avg_ns": 23840224,
+ "stddev_ns": 0,
+ "avg_ts": 1342.269267,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 23840224
+ ],
+ "samples_ts": [
+ 1342.27
+ ]
+ }
+ },
+ {
+ "pair": 2,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:17Z",
+ "avg_ns": 6928281,
+ "stddev_ns": 0,
+ "avg_ts": 9237.500615,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 6928281
+ ],
+ "samples_ts": [
+ 9237.5
+ ]
+ }
+ },
+ {
+ "pair": 2,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:17Z",
+ "avg_ns": 23471693,
+ "stddev_ns": 0,
+ "avg_ts": 1363.344348,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 23471693
+ ],
+ "samples_ts": [
+ 1363.34
+ ]
+ }
+ },
+ {
+ "pair": 2,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:18Z",
+ "avg_ns": 13663349,
+ "stddev_ns": 0,
+ "avg_ts": 4684.063914,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 13663349
+ ],
+ "samples_ts": [
+ 4684.06
+ ]
+ }
+ },
+ {
+ "pair": 2,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:18Z",
+ "avg_ns": 31077683,
+ "stddev_ns": 0,
+ "avg_ts": 1029.677792,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 31077683
+ ],
+ "samples_ts": [
+ 1029.68
+ ]
+ }
+ },
+ {
+ "pair": 3,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:19Z",
+ "avg_ns": 13714791,
+ "stddev_ns": 0,
+ "avg_ts": 4666.494736,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 13714791
+ ],
+ "samples_ts": [
+ 4666.49
+ ]
+ }
+ },
+ {
+ "pair": 3,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:19Z",
+ "avg_ns": 31527795,
+ "stddev_ns": 0,
+ "avg_ts": 1014.977419,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 31527795
+ ],
+ "samples_ts": [
+ 1014.98
+ ]
+ }
+ },
+ {
+ "pair": 3,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:20Z",
+ "avg_ns": 6447865,
+ "stddev_ns": 0,
+ "avg_ts": 9925.766126,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 6447865
+ ],
+ "samples_ts": [
+ 9925.77
+ ]
+ }
+ },
+ {
+ "pair": 3,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:20Z",
+ "avg_ns": 20774417,
+ "stddev_ns": 0,
+ "avg_ts": 1540.356102,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 20774417
+ ],
+ "samples_ts": [
+ 1540.36
+ ]
+ }
+ },
+ {
+ "pair": 4,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:22Z",
+ "avg_ns": 6293932,
+ "stddev_ns": 0,
+ "avg_ts": 10168.524223,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 6293932
+ ],
+ "samples_ts": [
+ 10168.5
+ ]
+ }
+ },
+ {
+ "pair": 4,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:22Z",
+ "avg_ns": 23256588,
+ "stddev_ns": 0,
+ "avg_ts": 1375.954203,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 23256588
+ ],
+ "samples_ts": [
+ 1375.95
+ ]
+ }
+ },
+ {
+ "pair": 4,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:23Z",
+ "avg_ns": 12523098,
+ "stddev_ns": 0,
+ "avg_ts": 5110.556509,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 12523098
+ ],
+ "samples_ts": [
+ 5110.56
+ ]
+ }
+ },
+ {
+ "pair": 4,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:23Z",
+ "avg_ns": 29540373,
+ "stddev_ns": 0,
+ "avg_ts": 1083.263234,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 29540373
+ ],
+ "samples_ts": [
+ 1083.26
+ ]
+ }
+ },
+ {
+ "pair": 5,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:24Z",
+ "avg_ns": 12473620,
+ "stddev_ns": 0,
+ "avg_ts": 5130.8281,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 12473620
+ ],
+ "samples_ts": [
+ 5130.83
+ ]
+ }
+ },
+ {
+ "pair": 5,
+ "path": "baseline",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": false,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:24Z",
+ "avg_ns": 29765885,
+ "stddev_ns": 0,
+ "avg_ts": 1075.056226,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 29765885
+ ],
+ "samples_ts": [
+ 1075.06
+ ]
+ }
+ },
+ {
+ "pair": 5,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 64,
+ "n_gen": 0,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:25Z",
+ "avg_ns": 6169792,
+ "stddev_ns": 0,
+ "avg_ts": 10373.121168,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 6169792
+ ],
+ "samples_ts": [
+ 10373.1
+ ]
+ }
+ },
+ {
+ "pair": 5,
+ "path": "kleidiai",
+ "measurement": {
+ "build_commit": "unknown",
+ "build_number": 0,
+ "cpu_info": "CPU",
+ "gpu_info": "",
+ "backends": "CPU",
+ "model_filename": "stories15M-q4_0.gguf",
+ "model_type": "llama ?B Q4_0",
+ "model_size": 18350208,
+ "model_n_params": 24407712,
+ "n_batch": 64,
+ "n_ubatch": 64,
+ "n_threads": 1,
+ "cpu_mask": "0x0",
+ "cpu_strict": false,
+ "poll": 50,
+ "type_k": "f16",
+ "type_v": "f16",
+ "n_gpu_layers": 0,
+ "n_cpu_moe": 0,
+ "split_mode": "layer",
+ "main_gpu": 0,
+ "no_kv_offload": false,
+ "flash_attn": -1,
+ "devices": "auto",
+ "tensor_split": "0.00",
+ "tensor_buft_overrides": "none",
+ "load_mode": "auto",
+ "lazy_mode": "auto",
+ "embeddings": false,
+ "no_op_offload": 0,
+ "no_host": false,
+ "repack": true,
+ "fit_target": 0,
+ "fit_min_ctx": 0,
+ "n_prompt": 0,
+ "n_gen": 32,
+ "n_depth": 0,
+ "test_time": "2026-11-05T21:48:25Z",
+ "avg_ns": 21331172,
+ "stddev_ns": 0,
+ "avg_ts": 1500.151984,
+ "stddev_ts": 0.0,
+ "samples_ns": [
+ 21331172
+ ],
+ "samples_ts": [
+ 1500.15
+ ]
+ }
+ }
+ ],
+ "output_check": {
+ "prompts": 8,
+ "pass": true,
+ "check": "limited quantized-output agreement smoke check; not model quality validation",
+ "criteria_history": "Criteria fixed before this fresh run: all logits finite, same top-1 next token, total variation <= 0.03 and KL(baseline || optimized) <= 0.005 on eight fixed prompts. Informed by an earlier separate session; smoke check only.",
+ "logits_compared": 256000,
+ "max_abs_error": 0.4564218521118164,
+ "rmse": 0.11349425579578948,
+ "total_variation_tolerance": 0.03,
+ "kl_tolerance": 0.005,
+ "agreement": [
+ {
+ "prompt": 1,
+ "total_variation": 0.0134702033245219,
+ "kl_baseline_to_kleidiai": 0.0005354235940988207,
+ "top1_equal": true
+ },
+ {
+ "prompt": 2,
+ "total_variation": 0.019507935817297203,
+ "kl_baseline_to_kleidiai": 0.0011837684436163374,
+ "top1_equal": true
+ },
+ {
+ "prompt": 3,
+ "total_variation": 0.018306560910857528,
+ "kl_baseline_to_kleidiai": 0.0010939228771188782,
+ "top1_equal": true
+ },
+ {
+ "prompt": 4,
+ "total_variation": 0.024712289378606207,
+ "kl_baseline_to_kleidiai": 0.0016032290230182692,
+ "top1_equal": true
+ },
+ {
+ "prompt": 5,
+ "total_variation": 0.012938356482563725,
+ "kl_baseline_to_kleidiai": 0.00046064009451435355,
+ "top1_equal": true
+ },
+ {
+ "prompt": 6,
+ "total_variation": 0.027987955141825324,
+ "kl_baseline_to_kleidiai": 0.0020856395387239763,
+ "top1_equal": true
+ },
+ {
+ "prompt": 7,
+ "total_variation": 0.006165250301568934,
+ "kl_baseline_to_kleidiai": 0.0002926755020512138,
+ "top1_equal": true
+ },
+ {
+ "prompt": 8,
+ "total_variation": 0.00173795921717995,
+ "kl_baseline_to_kleidiai": 7.088784449888363e-05,
+ "top1_equal": true
+ }
+ ],
+ "top1": [
+ {
+ "prompt": 1,
+ "baseline_top1": 304,
+ "kleidiai_top1": 304
+ },
+ {
+ "prompt": 2,
+ "baseline_top1": 4802,
+ "kleidiai_top1": 4802
+ },
+ {
+ "prompt": 3,
+ "baseline_top1": 577,
+ "kleidiai_top1": 577
+ },
+ {
+ "prompt": 4,
+ "baseline_top1": 14089,
+ "kleidiai_top1": 14089
+ },
+ {
+ "prompt": 5,
+ "baseline_top1": 1554,
+ "kleidiai_top1": 1554
+ },
+ {
+ "prompt": 6,
+ "baseline_top1": 2217,
+ "kleidiai_top1": 2217
+ },
+ {
+ "prompt": 7,
+ "baseline_top1": 5447,
+ "kleidiai_top1": 5447
+ },
+ {
+ "prompt": 8,
+ "baseline_top1": 748,
+ "kleidiai_top1": 748
+ }
+ ]
+ },
+ "kernel_execution": {
+ "diagnostic_counts": {
+ "baseline": [],
+ "kleidiai": [
+ {
+ "mode": "GEMM",
+ "required_cpu": 3,
+ "calls": 78
+ },
+ {
+ "mode": "GEMV",
+ "required_cpu": 3,
+ "calls": 395
+ }
+ ]
+ },
+ "feature_mask": {
+ "DOTPROD": 1,
+ "I8MM": 2,
+ "SVE": 4,
+ "SVEI8MM": 64
+ },
+ "dispatch_constraint": "KleidiAI SVE kernels require 32-byte vectors; runtime vector length was 16 bytes.",
+ "verified_implementations": [
+ "Neon I8MM GEMM",
+ "Neon dot-product GEMV"
+ ],
+ "instrumentation": "Marker emitted after selected kernel returned; source restored and rebuilt before timing; timing library checked for absence of marker.",
+ "timing_binary_checksums": [
+ "5151715e581ec32404c3183e4c42ae51cd39f2e9ab0fcd35b3a7294d33aa3a48 build/bin/llama-bench",
+ "ba5708a7b7adabb28445d8167ff0097fb4a753907c0c8db955db90cca3cf1c1d build/bin/libggml-cpu.so"
+ ]
+ },
+ "cleanup": {
+ "cloud_state": "FINISHED",
+ "active_start_time": "2026-11-05T21:39:11.203881Z",
+ "finished_expire_time": "2026-11-05T21:50:23.317744Z",
+ "exact_adb_serial_disconnected": true,
+ "viewer_and_forwarder_stopped": true
+ }
+}
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/images/ddp-connected-phone.jpg b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/images/ddp-connected-phone.jpg
new file mode 100644
index 0000000000..eb521ec18b
Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/images/ddp-connected-phone.jpg differ
diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/images/ddp-pixel11-catalog.jpg b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/images/ddp-pixel11-catalog.jpg
new file mode 100644
index 0000000000..13ab73c24a
Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/images/ddp-pixel11-catalog.jpg differ