Refine AI agent Learning Path: title, metadata, setup, and Ollama steps

Author: jaidev17

content/learning-paths/cross-platform/ai-agent-cpu-orchestration/1-overview.md

@@ -10,7 +10,8 @@ layout: learningpathall
 
 In this Learning Path, you'll build and run a *local concierge agent*: a terminal application that answers research-style questions, such as finding restaurants, comparing products, or summarizing a topic, by searching the web, reading multiple pages, and writing a fact-checked summary.
 
-Everything runs on your own Arm machine. The agent uses a large language model (LLM) served locally by [Ollama](https://ollama.com/), so your prompts and the pages you browse never leave the device. The same code runs on an Apple silicon MacBook, an Arm Linux laptop, or an NVIDIA DGX Spark.
+Everything runs on your own Arm machine. The agent uses an LLM served locally by [Ollama](https://ollama.com/), so your prompts and the pages you browse never leave the device. The same code runs on an Apple silicon MacBook, an Arm Linux laptop, or an NVIDIA DGX Spark.
+
 
 The agent is interesting not just because it runs locally, but because of *how the work is divided*. A common assumption is that an AI agent is "just the model." In practice, the model is only one stage in a longer pipeline, and most of the surrounding work runs on the CPU.
 
@@ -29,7 +30,7 @@ Your question
     -> Write a fact-checked summary         (GPU: model reasoning)
 ```
 
-The model is called several times, but between every model call the CPU does a large amount of orchestration: generating query variants, dispatching parallel network requests, merging and deduplicating results, scoring pages for relevance, and extracting structured data such as phone numbers and opening hours.
+The model is called several times, but between every model call the CPU does a large amount of orchestration: generating query variants, dispatching parallel network requests, merging and deduplicating results, scoring pages for relevance, and extracting structured data.
 
 ## Why the CPU matters in an agentic workflow
 
@@ -48,8 +49,8 @@ This division is a natural fit for Arm platforms. On an Apple silicon MacBook or
 
 The program is instrumented so you can see this division directly. As it runs, it prints:
 
-- `[CPU]` log lines (in cyan) for every orchestration and processing step
-- `[GPU]` log lines (in yellow) for every model call
+- <code style="color:#00aaaa"><strong>[CPU]</strong></code> log lines for every orchestration and processing step
+- <code style="color:#aaaa00"><strong>[GPU]</strong></code> log lines for every model call
 - A timing breakdown of CPU time versus GPU input-token processing and token generation
 - A text-based timeline that visualizes when the CPU and GPU are each active
 

content/learning-paths/cross-platform/ai-agent-cpu-orchestration/2-setup.md

@@ -21,10 +21,6 @@ The agent searches the web through [Serper](https://serper.dev/), a Google Searc
 
 You'll set this key as an environment variable later in this section, so the agent can read it without the key being written into the code.
 
-{{% notice Note %}}
-Never paste your API key directly into source code that you share or commit. Always read it from an environment variable, as shown below.
-{{% /notice %}}
-
 ## Create a project directory and virtual environment
 
 A virtual environment keeps the agent's dependencies isolated from your system Python, so you always run against the right package versions.
@@ -47,7 +43,7 @@ Your shell prompt now shows `(.venv)`, which confirms the environment is active.
 
 ## Install the required packages
 
-The agent uses `requests` for HTTP calls and `beautifulsoup4` to parse web pages. The remaining libraries it uses, such as `smtplib`, `json`, and `concurrent.futures`, are part of the Python standard library.
+The agent uses `requests` for HTTP calls and `beautifulsoup4` to parse web pages.
 
 Install the two packages:
 
@@ -69,12 +65,12 @@ This variable only lasts for the current terminal session. To keep it across ses
 
 ## Download the agent script
 
-Download the complete agent script, [concierge_agent.py](concierge_agent.py), into your project directory. You'll run it at the end of this Learning Path, and the next sections walk through how the important parts work.
+Download the complete agent script, <a href="/learning-paths/cross-platform/ai-agent-cpu-orchestration/concierge_agent.py" download>concierge_agent.py</a>, and move it into your `concierge-agent` directory. You'll run it at the end of this Learning Path, and the next sections walk through how the important parts work.
 
-Download it directly from the command line:
+Alternatively, download it directly from the command line:
 
 ```bash
-curl -O https://learn.arm.com/learning-paths/cross-platform/ai-agent-cpu-orchestration/concierge_agent.py
+curl -O https://raw.githubusercontent.com/ArmDeveloperEcosystem/arm-learning-paths/main/content/learning-paths/cross-platform/ai-agent-cpu-orchestration/concierge_agent.py
 ```
 
 Confirm the file is in your project directory:
@@ -83,8 +79,4 @@ Confirm the file is in your project directory:
 ls concierge_agent.py
 ```
 
-{{% notice Tip %}}
-You can also save the file using the [concierge_agent.py](concierge_agent.py) link above, then move it into your `concierge-agent` directory.
-{{% /notice %}}
-
 With the environment ready and the script in place, the next step is to serve a model locally with Ollama.

content/learning-paths/cross-platform/ai-agent-cpu-orchestration/3-ollama.md

@@ -8,46 +8,38 @@ layout: learningpathall
 
 ## Run AI models locally with Ollama
 
-The agent's reasoning steps, such as choosing search terms, selecting URLs, and writing the final summary, are handled by a large language model. Instead of calling a cloud API, this Learning Path serves the model locally with [Ollama](https://ollama.com/).
+The agent's reasoning steps, such as choosing search terms, selecting URLs, and writing the final summary, are handled by an LLM. Instead of calling a cloud API, this Learning Path serves the model locally with [Ollama](https://ollama.com/).
 
-Ollama is a lightweight runtime that downloads open models, loads them into memory, and exposes a local HTTP API at `http://localhost:11434`. When the agent calls that endpoint, the model runs directly on your machine: the CPU and GPU on your MacBook, Arm Linux laptop, or NVIDIA DGX Spark. Nothing is sent to an external service.
+Ollama is a lightweight runtime that downloads open models, loads them into memory, and exposes a local HTTP API at `http://localhost:11434`. When the agent calls that endpoint, the model runs directly on your machine: the CPU and GPU on your MacBook, Arm Linux laptop, or NVIDIA DGX Spark. Nothing is sent to an external service or cloud.
 
 Running locally has three benefits that matter for an agent:
 
 - **Privacy**: your prompts and the web content the agent reads stay on the device.
 - **Cost**: there are no per-token API charges, so you can run many queries freely.
 - **Control**: you choose the exact model and keep it resident in memory for fast repeated calls.
 
-## Install Ollama
+## Install and start Ollama
 
-Install Ollama for your operating system.
+Install [Ollama](https://ollama.com/) and start its server using one of the following options. The server exposes a local API at `http://localhost:11434` that the agent connects to.
 
 {{< tabpane code=true >}}
-{{< tab header="macOS" language="bash">}}
+{{< tab header="Homebrew (Recommended)" language="bash">}}
+# Install Ollama
 brew install ollama
+
+# Start the server as a background service (no terminal to keep open)
+brew services start ollama
 {{< /tab >}}
-{{< tab header="Linux" language="bash">}}
+{{< tab header="Install script" language="bash">}}
+# Install Ollama
 curl -fsSL https://ollama.com/install.sh | sh
-{{< /tab >}}
-{{< /tabpane >}}
-
-{{% notice Note %}}
-On macOS you can also download the Ollama desktop app from [ollama.com/download](https://ollama.com/download). On an NVIDIA DGX Spark, follow the Linux instructions; Ollama uses the Blackwell GPU for inference automatically.
-{{% /notice %}}
-
-## Start the Ollama server
 
-Start the Ollama background service, which hosts the local API the agent connects to:
-
-```bash
+# Start the server (leave this running, and open a second terminal)
 ollama serve
-```
-
-Leave this running in its own terminal. Open a second terminal for the remaining commands.
+{{< /tab >}}
+{{< /tabpane >}}
 
-{{% notice Tip %}}
-On macOS, starting the Ollama desktop app already runs the server in the background, so you can skip `ollama serve`.
-{{% /notice %}}
+With [Homebrew](https://brew.sh/), `brew services` runs Ollama in the background, so you can use the same terminal throughout. With the install script, `ollama serve` runs in the foreground, so keep that terminal open and use a second terminal for the remaining commands.
 
 ## Pull the Gemma model
 

content/learning-paths/cross-platform/ai-agent-cpu-orchestration/_index.md

@@ -1,5 +1,5 @@
 ---
-title: Build a CPU-orchestrated local AI agent with Ollama and Gemma
+title: Build and run a local AI agent with Ollama
 
 description: Learn how to build a local AI concierge agent that runs entirely on your Arm machine, using the CPU to orchestrate web search, scraping, and text processing while a local Gemma model handles reasoning on the GPU.
 
@@ -9,18 +9,17 @@ cascade:
 
 minutes_to_complete: 45
 
-who_is_this_for: This is an introductory topic for developers who want to build a local, privacy-friendly AI agent on Arm hardware and understand how the CPU orchestrates an agentic workflow around a locally served large language model.
+who_is_this_for: This is an introductory topic for developers who want to build a local, privacy-friendly AI agent on Arm hardware and visualize how the CPU orchestrates an agentic workflow around a locally served LLM.
 
 learning_objectives:
-    - Set up a Python environment and obtain the API access needed to run a local AI agent
-    - Serve a large language model locally with Ollama and select a model that fits your hardware
+    - Set up a Python environment and obtain a Serper web search API key for the agent
+    - Serve an LLM locally with Ollama and select a model that fits your hardware
     - Explain how the CPU orchestrates an agentic workflow while the GPU handles model inference
     - Run the agent and interpret the CPU and GPU timeline it produces for each query
 
 prerequisites:
     - An Arm-based computer running Linux or macOS, such as an Apple silicon MacBook or an NVIDIA DGX Spark
     - Familiarity with running Python scripts from the terminal
-    - A free Serper API key for web search
 
 author: Jaidev Singh Chadha
 
@@ -37,7 +36,6 @@ armips:
 tools_software_languages:
     - Python
     - Ollama
-    - Gemma
     - Generative AI
     - LLM
 operatingsystems: