Fix links and update images

Signed-off-by: Marc Duiker <marcduiker@users.noreply.github.com>

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-core-concepts.md

@@ -18,7 +18,7 @@ Dapr Agents is designed to place agents, powered by LLMs, at the core of task ex
 
 While Dapr Agents centers around agents, it also recognizes the versatility of using LLMs directly in deterministic workflows or simpler task sequences. In scenarios where the agent's built-in task-handling patterns, like `tool calling` or `ReAct` loops, are unnecessary, LLMs can act as core components for reasoning and decision-making. This flexibility ensures users can adapt Dapr Agents to suit diverse needs without being confined to a single approach.
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 Agents are not standalone; they are building blocks in larger, orchestrated workflows.
 {{% /alert %}}
 
@@ -29,7 +29,7 @@ Dapr Agents ensures a clean separation between agents and the underlying infrast
 * **Agent Simplicity**: Agents focus purely on reasoning and task execution, while Pub/Sub messaging, routing, and validation are managed externally by modular infrastructure components.
 * **Scalable and Adaptable Systems**: By offloading non-agent-specific responsibilities, Dapr Agents allows agents to scale independently and adapt seamlessly to new use cases or integrations.
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 Decoupling infrastructure keeps agents focused on tasks while enabling seamless scalability and integration across systems.
 {{% /alert %}}
 
@@ -37,14 +37,14 @@ Decoupling infrastructure keeps agents focused on tasks while enabling seamless
 
 ### Modular Component Model
 
-Dapr Agents utilizes [Dapr's pluggable component framework](https://docs.dapr.io/concepts/components-concept/) and building blocks to simplify development and enhance flexibility:
+Dapr Agents utilizes [Dapr's component framework]({{% ref components-concept.md %}}) and building blocks to simplify development and enhance flexibility:
 
 * **Building Blocks for Core Functionality**: Dapr provides API building blocks, such as Pub/Sub messaging, state management, service invocation, and more, to address common microservice challenges and promote best practices.
 * **Interchangeable Components**: Each building block operates on swappable components (e.g., Redis, Kafka, Azure CosmosDB), allowing you to replace implementations without changing application code.
 * **Seamless Transitions**: Develop locally with default configurations and deploy effortlessly to cloud environments by simply updating component definitions.
 * **Scalable Foundations**: Build resilient and adaptable architectures using Dapr's modular, production-ready building blocks.
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 Developers can easily switch between different components (e.g., Redis to DynamoDB) based on their deployment environment, ensuring portability and adaptability.
 {{% /alert %}}
 
@@ -58,7 +58,7 @@ Dapr Agents emphasizes the use of Pub/Sub messaging for event-driven communicati
 * **Real-Time Adaptability**: Agents react dynamically to events for faster, more flexible task execution.
 * **Seamless Collaboration**: Agents share updates, distribute tasks, and respond to events in a highly coordinated way.
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 Pub/Sub messaging serves as the backbone for Dapr Agents' event-driven workflows, enabling agents to communicate and collaborate in real time.
 {{% /alert %}}
 
@@ -66,14 +66,14 @@ Pub/Sub messaging serves as the backbone for Dapr Agents' event-driven workflows
 
 ### Workflow-Oriented Design
 
-Dapr Agents embraces workflows as a foundational concept, integrating [Dapr Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/) to support both deterministic and event-driven task orchestration. This dual approach enables robust and adaptive systems:
+Dapr Agents embraces workflows as a foundational concept, integrating [Dapr Workflows]({{% ref workflow-overview.md %}}) to support both deterministic and event-driven task orchestration. This dual approach enables robust and adaptive systems:
 
 * **Deterministic Workflows**: Dapr Agents uses Dapr Workflows for stateful, predictable task sequences. These workflows ensure reliable execution, fault tolerance, and state persistence, making them ideal for structured, multi-step processes that require clear, repeatable logic.
 * **Event-Driven Workflows**: By combining Dapr Workflows with Pub/Sub messaging, Dapr Agents supports workflows that adapt to real-time events. This facilitates decentralized, asynchronous collaboration between agents, allowing workflows to dynamically adjust to changing scenarios.
 
 By integrating these paradigms, Dapr Agents enables workflows that combine the reliability of deterministic execution with the adaptability of event-driven processes, ensuring flexibility and resilience in a wide range of applications.
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 Dapr Agents workflows blend structured, predictable logic with the dynamic responsiveness of event-driven systems, empowering both centralized and decentralized workflows.
 {{% /alert %}}
 
@@ -113,15 +113,15 @@ Dapr Agents supports flexible prompt templates to shape agent behavior and reaso
 
 #### 7. Agent Services
 
-Agents are exposed as independent services using [FastAPI and Dapr applications](https://docs.dapr.io/developing-applications/sdks/python/python-sdk-extensions/python-fastapi/). This modular approach separates the agent's logic from its service layer, enabling seamless reuse, deployment, and integration into multi-agent systems.
+Agents are exposed as independent services using [FastAPI and Dapr applications]({{% ref python-fastapi.md %}}). This modular approach separates the agent's logic from its service layer, enabling seamless reuse, deployment, and integration into multi-agent systems.
 
 #### 8. Message-Driven Communication
 
-Agents collaborate through [Pub/Sub messaging](https://docs.dapr.io/developing-applications/building-blocks/pubsub/pubsub-overview/), enabling event-driven communication and task distribution. This message-driven architecture allows agents to work asynchronously, share updates, and respond to real-time events, ensuring effective collaboration in distributed systems.
+Agents collaborate through [Pub/Sub messaging]({{% ref pubsub-overview.md %}}), enabling event-driven communication and task distribution. This message-driven architecture allows agents to work asynchronously, share updates, and respond to real-time events, ensuring effective collaboration in distributed systems.
 
 #### 9. Workflow Orchestration
 
-Dapr Agents supports both deterministic and event-driven workflows to manage multi-agent systems via [Dapr Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/). Deterministic workflows provide clear, repeatable processes, while event-driven workflows allow for dynamic, adaptive collaboration between agents in centralized or decentralized architectures.
+Dapr Agents supports both deterministic and event-driven workflows to manage multi-agent systems via [Dapr Workflows]({{% ref workflow-overview.md %}}). Deterministic workflows provide clear, repeatable processes, while event-driven workflows allow for dynamic, adaptive collaboration between agents in centralized or decentralized architectures.
 
 ### Agent Types
 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-getting-started.md

@@ -7,45 +7,17 @@ description: "How to install Dapr Agents and run your first agent"
 ---
 
 {{% alert title="Dapr Agents Concepts" color="primary" %}}
-If you are looking for an introductory overview of Dapr Agents and want to learn more about basic Dapr Agents terminology, we recommend starting with the [introduction](dapr-agents-introduction.md) and [concepts](dapr-agents-core-concepts.md) sections.
+If you are looking for an introductory overview of Dapr Agents and want to learn more about basic Dapr Agents terminology, we recommend starting with the [introduction]({{% ref dapr-agents-introduction.md %}}) and [concepts]({{% ref dapr-agents-core-concepts.md %}}) sections.
 {{% /alert %}}
 
-## Install Dapr CLI
+## Install & Initialize Dapr CLI
 
-While simple examples in Dapr Agents can be used without the sidecar, the recommended mode is with the Dapr sidecar. To benefit from the full power of Dapr Agents, install the Dapr CLI for running Dapr locally or on Kubernetes for development purposes. For a complete step-by-step guide, follow the  [Dapr CLI installation page](https://docs.dapr.io/getting-started/install-dapr-cli/).
+While simple examples in Dapr Agents can be used without the sidecar, the recommended mode is with the Dapr sidecar. To benefit from the full power of Dapr Agents, install the Dapr CLI for running Dapr locally or on Kubernetes for development purposes. Follow the instructions on the [Install Dapr CLI page]({{% ref install-dapr-cli.md %}}) and the [Init Dapr locally page]({{% ref install-dapr-selfhost.md %}}). After installing the CLI and initializing Dapr, come back to this page.
 
 
-Verify the CLI is installed by restarting your terminal/command prompt and running the following:
-
-```bash
-dapr -h
-```
-
-## Initialize Dapr in Local Mode
-
-{{% alert title="Note" color="info" %}}
-Make sure you have [Docker](https://docs.docker.com/get-started/get-docker/) already installed.
-{{% /alert %}}
-
-Initialize Dapr locally to set up a self-hosted environment for development. This process fetches and installs the Dapr sidecar binaries, runs essential services as Docker containers, and prepares a default components folder for your application. For detailed steps, see the official [guide on initializing Dapr locally](https://docs.dapr.io/getting-started/install-dapr-selfhost/).
-
-![Dapr Initialization](/images/dapr-agents/home_installation_init.png)
-
-To initialize the Dapr control plane containers and create a default configuration file, run:
-
-```bash
-dapr init
-```
-
-Verify you have container instances with `daprio/dapr`, `openzipkin/zipkin`, and `redis` images running:
-
-```bash
-docker ps
-```
-
 ## Install Python
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 Make sure you have Python already installed. `Python >=3.10`. For installation instructions, visit the official [Python installation guide](https://www.python.org/downloads/).
 {{% /alert %}}
 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-integrations.md

@@ -13,9 +13,9 @@ Dapr Agents integrates with popular Python frameworks and tools.
 
 | Framework | Integration | Description |
 |-----------|-------------|-------------|
-| [**FastAPI**]({{< ref "dapr-agents-getting-started.md#fastapi-integration" >}}) | Native | Expose agents as REST APIs with automatic documentation and validation
-| [**Chainlit**]({{< ref "dapr-agents-quickstarts.md#chainlit-integration" >}}) | Supported | Build conversational UIs for agent interactions with file upload and chat capabilities
-| [**Pydantic**]({{< ref "dapr-agents-core-concepts.md#pydantic-integration" >}}) | Built-in | Type-safe configuration and structured outputs for agents and tools
+| [**FastAPI**]({{% ref "dapr-agents-getting-started.md#fastapi-integration" %}}) | Native | Expose agents as REST APIs with automatic documentation and validation
+| [**Chainlit**]({{% ref "dapr-agents-quickstarts.md#chainlit-integration" %}}) | Supported | Build conversational UIs for agent interactions with file upload and chat capabilities
+| [**Pydantic**]({{% ref "dapr-agents-core-concepts.md#pydantic-integration" %}}) | Built-in | Type-safe configuration and structured outputs for agents and tools
 
 
 
@@ -115,7 +115,7 @@ if not local_pdf_path.exists():
 
 For this example, we use Dapr Agents' `PyPDFReader`.
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 The PyPDF Reader relies on the [pypdf python library](https://pypi.org/project/pypdf/), which is not included in the Dapr Agents core module. This design choice helps maintain modularity and avoids adding unnecessary dependencies for users who may not require this functionality. To use the PyPDF Reader, ensure that you install the library separately.
 {{% /alert %}}
 
@@ -177,7 +177,7 @@ The Arxiv Fetcher simplifies the process of accessing research papers, offering
 
 #### Step 1: Install Required Modules
 
-{{% alert title="Note" color="info" %}}
+{{% alert title="Note" color="primary" %}}
 The Arxiv Fetcher relies on a [lightweight Python wrapper](https://github.com/lukasschwab/arxiv.py) for the arXiv API, which is not included in the Dapr Agents core module. This design choice helps maintain modularity and avoids adding unnecessary dependencies for users who may not require this functionality. To use the Arxiv Fetcher, ensure you install the [library](https://pypi.org/project/arxiv/) separately.
 {{% /alert %}}
 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-introduction.md

@@ -8,7 +8,7 @@ description: "Overview of Dapr Agents and its key features"
 
 ![Agent Overview](/images/dapr-agents/concepts-agents-overview.png)
 
-[Dapr Agents](https://github.com/dapr/dapr-agents/) is a developer framework for building production-grade, resilient AI agent systems powered by Large Language Models (LLMs). Built on the battle-tested Dapr project, it enables developers to create autonomous systems that reason through problems, make dynamic decisions, and collaborate seamlessly. It includes built-in observability and stateful workflow execution to ensure agentic workflows complete successfully, regardless of complexity. Whether you're developing single-agent applications or complex multi-agent workflows, Dapr Agents provides the infrastructure for intelligent, adaptive systems that scale across environments.
+Dapr Agents is a developer framework for building production-grade, resilient AI agent systems powered by Large Language Models (LLMs). Built on the battle-tested Dapr project, it enables developers to create autonomous systems that reason through problems, make dynamic decisions, and collaborate seamlessly. It includes built-in observability and stateful workflow execution to ensure agentic workflows complete successfully, regardless of complexity. Whether you're developing single-agent applications or complex multi-agent workflows, Dapr Agents provides the infrastructure for intelligent, adaptive systems that scale across environments.
 
 
 ## Core Capabilities
@@ -28,15 +28,15 @@ Dapr Agents provides specialized modules designed for creating intelligent, auto
  
 | Building Block                                                                               | Description |
 |----------------------------------------------------------------------------------------------|-------------|
-| [**LLM Integration**]({{< ref "dapr-agents-core-concepts.md#llm-integration" >}})            | Uses Dapr [Conversation API](https://docs.dapr.io/developing-applications/building-blocks/conversation/conversation-overview/) to abstract LLM inference APIs for chat completion, or provides native clients for other LLM integrations such as embeddings, audio, etc.
-| [**Structured Outputs**]({{< ref "dapr-agents-core-concepts.md#structured-outputs" >}})      | Leverage capabilities like OpenAI's Function Calling to generate predictable, reliable results following JSON Schema and OpenAPI standards for tool integration.
-| [**Tool Selection**]({{< ref "dapr-agents-integrations.md#tool-selection" >}})                      | Dynamic tool selection based on requirements, best action, and execution through [Function Calling](https://platform.openai.com/docs/guides/function-calling) capabilities.
-| [**MCP Support**]({{< ref "dapr-agents-integrations.md#mcp-support" >}})                            | Built-in support for [Model Context Protocol](https://modelcontextprotocol.io/) enabling agents to dynamically discover and invoke external tools through standardized interfaces.
-| [**Memory Management**]({{< ref "dapr-agents-core-concepts.md#memory-management" >}})        | Retain context across interactions with options from simple in-memory lists to vector databases, integrating with [Dapr state stores](https://docs.dapr.io/developing-applications/building-blocks/state-management/state-management-overview/) for scalable, persistent memory.
-| [**Durable Agents**]({{< ref "dapr-agents-core-concepts.md#durable-agents" >}})              | Workflow-backed agents that provide fault-tolerant execution with persistent state management and automatic retry mechanisms for long-running processes.
-| [**Headless Agents**]({{< ref "dapr-agents-core-concepts.md#agent-services" >}})               | Expose agents over REST for long-running tasks, enabling programmatic access and integration without requiring user interfaces or human intervention.
-| [**Event-Driven Communication**]({{< ref "dapr-agents-core-concepts.md#messaging" >}})       | Enable agent collaboration through [Pub/Sub messaging](https://docs.dapr.io/developing-applications/building-blocks/pubsub/pubsub-overview/) for event-driven communication, task distribution, and real-time coordination in distributed systems.
-| [**Agent Orchestration**]({{< ref "dapr-agents-core-concepts.md#workflow-orchestration" >}}) | Deterministic agent orchestration using [Dapr Workflows](https://docs.dapr.io/developing-applications/building-blocks/workflow/workflow-overview/) with higher-level tasks that interact with LLMs for complex multi-step processes.
+| [**LLM Integration**]({{% ref "dapr-agents-core-concepts.md#1-llm-integration" %}})            | Uses Dapr [Conversation API]({{% ref conversation-overview.md %}}) to abstract LLM inference APIs for chat completion, or provides native clients for other LLM integrations such as embeddings, audio, etc.
+| [**Structured Outputs**]({{% ref "dapr-agents-core-concepts.md#2-structured-outputs" %}})      | Leverage capabilities like OpenAI's Function Calling to generate predictable, reliable results following JSON Schema and OpenAPI standards for tool integration.
+| [**Tool Selection**]({{% ref "dapr-agents-core-concepts.md#3-tool-selection" %}})                      | Dynamic tool selection based on requirements, best action, and execution through [Function Calling](https://platform.openai.com/docs/guides/function-calling) capabilities.
+| [**MCP Support**]({{% ref "dapr-agents-core-concepts.md#4-mcp-support" %}})                            | Built-in support for [Model Context Protocol](https://modelcontextprotocol.io/) enabling agents to dynamically discover and invoke external tools through standardized interfaces.
+| [**Memory Management**]({{% ref "dapr-agents-core-concepts.md#5-memory" %}})        | Retain context across interactions with options from simple in-memory lists to vector databases, integrating with [Dapr state stores]({{% ref state-management-overview.md %}}) for scalable, persistent memory.
+| [**Durable Agents**]({{% ref "dapr-agents-core-concepts.md#durableagent" %}})              | Workflow-backed agents that provide fault-tolerant execution with persistent state management and automatic retry mechanisms for long-running processes.
+| [**Headless Agents**]({{% ref "dapr-agents-core-concepts.md#7-agent-services" %}})               | Expose agents over REST for long-running tasks, enabling programmatic access and integration without requiring user interfaces or human intervention.
+| [**Event-Driven Communication**]({{% ref "dapr-agents-core-concepts.md#8-message-driven-communication" %}})       | Enable agent collaboration through [Pub/Sub messaging]({{% ref pubsub-overview.md %}}) for event-driven communication, task distribution, and real-time coordination in distributed systems.
+| [**Agent Orchestration**]({{% ref "dapr-agents-core-concepts.md#9-workflow-orchestration" %}}) | Deterministic agent orchestration using [Dapr Workflows]({{% ref workflow-overview.md %}}) with higher-level tasks that interact with LLMs for complex multi-step processes.
  
  
 ## Agentic Patterns
@@ -48,13 +48,13 @@ These patterns exist along a spectrum of autonomy, from predictable workflow-bas
 
 | Pattern                                                                                | Description |
 |----------------------------------------------------------------------------------------|-------------|
-| [**Augmented LLM**]({{< ref "dapr-agents-patterns.md#augmented-llm" >}})               | Enhances a language model with external capabilities like memory and tools, providing a foundation for AI-driven applications.
-| [**Prompt Chaining**]({{< ref "dapr-agents-patterns.md#prompt-chaining" >}})           | Decomposes complex tasks into a sequence of steps where each LLM call processes the output of the previous one.
-| [**Routing**]({{< ref "dapr-agents-patterns.md#routing" >}})                           | Classifies inputs and directs them to specialized follow-up tasks, enabling separation of concerns and expert specialization.
-| [**Parallelization**]({{< ref "dapr-agents-patterns.md#parallelization" >}})           | Processes multiple dimensions of a problem simultaneously with outputs aggregated programmatically for improved efficiency.
-| [**Orchestrator-Workers**]({{< ref "dapr-agents-patterns.md#orchestrator-workers" >}}) | Features a central orchestrator LLM that dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes results.
-| [**Evaluator-Optimizer**]({{< ref "dapr-agents-patterns.md#evaluator-optimizer" >}})   | Implements a dual-LLM process where one model generates responses while another provides evaluation and feedback in an iterative loop.
-| [**Durable Agent**]({{< ref "dapr-agents-patterns.md#durable-agent" >}})               | Extends the Augmented LLM by adding durability and persistence to agent interactions using Dapr's state stores.
+| [**Augmented LLM**]({{% ref "dapr-agents-patterns.md#augmented-llm" %}})               | Enhances a language model with external capabilities like memory and tools, providing a foundation for AI-driven applications.
+| [**Prompt Chaining**]({{% ref "dapr-agents-patterns.md#prompt-chaining" %}})           | Decomposes complex tasks into a sequence of steps where each LLM call processes the output of the previous one.
+| [**Routing**]({{% ref "dapr-agents-patterns.md#routing" %}})                           | Classifies inputs and directs them to specialized follow-up tasks, enabling separation of concerns and expert specialization.
+| [**Parallelization**]({{% ref "dapr-agents-patterns.md#parallelization" %}})           | Processes multiple dimensions of a problem simultaneously with outputs aggregated programmatically for improved efficiency.
+| [**Orchestrator-Workers**]({{% ref "dapr-agents-patterns.md#orchestrator-workers" %}}) | Features a central orchestrator LLM that dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes results.
+| [**Evaluator-Optimizer**]({{% ref "dapr-agents-patterns.md#evaluator-optimizer" %}})   | Implements a dual-LLM process where one model generates responses while another provides evaluation and feedback in an iterative loop.
+| [**Durable Agent**]({{% ref "dapr-agents-patterns.md#durable-agent" %}})               | Extends the Augmented LLM by adding durability and persistence to agent interactions using Dapr's state stores.
 
  
 ## Developer Experience
@@ -63,11 +63,11 @@ Dapr Agents is a Python framework built on top of the [Python Dapr SDK](https://
 
 ### Getting Started
 
-Get started with Dapr Agents by following the [installation guide]({{< ref "dapr-agents-getting-started.md" >}}).
+Get started with Dapr Agents by following the instructions on the [Getting Started page]({{% ref "dapr-agents-getting-started.md" %}}).
 
 ### Framework Integrations
 
-Dapr Agents integrates with popular Python frameworks and tools. For detailed integration guides and examples, see the [integrations guide]({{< ref "dapr-agents-integrations.md" >}}).
+Dapr Agents integrates with popular Python frameworks and tools. For detailed integration guides and examples, see the [integrations page]({{% ref "dapr-agents-integrations.md" %}}).
  
 ## Operational Support
 
@@ -75,10 +75,10 @@ Dapr Agents inherits Dapr's enterprise-grade operational capabilities, providing
 
 ### Built-in Operational Features
 
-- **[Observability](https://docs.dapr.io/concepts/observability-concept/)** - Distributed tracing, metrics collection, and logging for agent interactions and workflow execution
-- **[Security](https://docs.dapr.io/concepts/security-concept/)** - mTLS encryption, access control, and secrets management for secure agent communication
-- **[Resiliency](https://docs.dapr.io/concepts/resiliency-concept/)** - Automatic retries, circuit breakers, and timeout policies for fault-tolerant agent operations
-- **[Infrastructure Isolation](https://docs.dapr.io/concepts/components-concept/)** - Dapr components abstract LLM providers, memory stores, storage and messaging backends, enabling seamless transitions between development and production environments
+- **[Observability]({{% ref observability-concept.md %}})** - Distributed tracing, metrics collection, and logging for agent interactions and workflow execution
+- **[Security]({{% ref security-concept.md %}})** - mTLS encryption, access control, and secrets management for secure agent communication
+- **[Resiliency]({{% ref resiliency-concept.md %}})** - Automatic retries, circuit breakers, and timeout policies for fault-tolerant agent operations
+- **[Infrastructure Abstraction]({{% ref components-concept.md %}})** - Dapr components abstract LLM providers, memory stores, storage and messaging backends, enabling seamless transitions between development and production environments
 
 These capabilities enable teams to monitor agent performance, secure multi-agent communications, and ensure reliable execution of complex agentic workflows in production environments.
 
@@ -86,4 +86,4 @@ These capabilities enable teams to monitor agent performance, secure multi-agent
 
 Whether you're interested in enhancing the framework, adding new integrations, or improving documentation, we welcome contributions from the community.
 
-For development setup and guidelines, see our [Development Guide](https://docs.dapr.io/contributing/dapr-agents/).
+For development setup and guidelines, see our [Contributor Guide]({{% ref "contributing/dapr-agents.md" %}}).

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-patterns.md

@@ -28,7 +28,7 @@ The patterns in this documentation start with the Augmented LLM, then progress t
 
 The Augmented LLM pattern is the foundational building block for any kind of agentic system. It enhances a language model with external capabilities like memory and tools, providing a basic but powerful foundation for AI-driven applications.
 
-<img src="/images/dapr-agents/agents-augmented-llm.png" width=800 alt="Diagram showing how the augmented LLM pattern works">
+<img src="/images/dapr-agents/agents-augmented-llm.png" width=600 alt="Diagram showing how the augmented LLM pattern works">
 
 This pattern is ideal for scenarios where you need an LLM with enhanced capabilities but don't require complex orchestration or autonomous decision-making. The augmented LLM can access external tools, maintain conversation history, and provide consistent responses across interactions.
 
@@ -111,11 +111,11 @@ Dapr Agents' workflow orchestration provides:
 - **Workflow Persistence** - Long-running chained tasks survive process restarts
 - **Hybrid Execution** - Easily mix prompts, agent calls, and tool-equipped agents
 
-## Routing Pattern
+## Routing
 
 The Routing pattern addresses diverse request types by classifying inputs and directing them to specialized follow-up tasks. This allows for separation of concerns and creates specialized experts for different types of queries.
 
-<img src="/images/dapr-agents/agents-routing.png" width=800 alt="Diagram showing how the routing pattern works">
+<img src="/images/dapr-agents/agents-routing.png" width=600 alt="Diagram showing how the routing pattern works">
 
 **Use Cases:**
 - Resource optimization (sending simple queries to smaller models)
@@ -165,7 +165,7 @@ The advantages of Dapr's approach include:
 
 The Parallelization pattern enables processing multiple dimensions of a problem simultaneously, with outputs aggregated programmatically. This pattern improves efficiency for complex tasks with independent subtasks that can be processed concurrently.
 
-<img src="/images/dapr-agents/agents-parallelization.png" width=800 alt="Diagram showing how the parallelization pattern works">
+<img src="/images/dapr-agents/agents-parallelization.png" width=600 alt="Diagram showing how the parallelization pattern works">
 
 **Use Cases:**
 - Complex research (processing different aspects of a topic in parallel)
@@ -219,7 +219,7 @@ The benefits of using Dapr for parallelization include:
 
 For highly complex tasks where the number and nature of subtasks can't be known in advance, the Orchestrator-Workers pattern offers a powerful solution. This pattern features a central orchestrator LLM that dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results.
 
-<img src="/images/dapr-agents/agents-orchestrator-workers.png" width=800 alt="Diagram showing how the orchestrator-workers pattern works">
+<img src="/images/dapr-agents/agents-orchestrator-workers.png" width=600 alt="Diagram showing how the orchestrator-workers pattern works">
 
 Unlike previous patterns where workflows are predefined, the orchestrator determines the workflow dynamically based on the specific input.
 
@@ -277,7 +277,7 @@ The advantages of Dapr for the Orchestrator-Workers pattern include:
 
 Quality is often achieved through iteration and refinement. The Evaluator-Optimizer pattern implements a dual-LLM process where one model generates responses while another provides evaluation and feedback in an iterative loop.
 
-<img src="/images/dapr-agents/agents-evaluator-optimizer.png" width=800 alt="Diagram showing how the evaluator-optimizer pattern works">
+<img src="/images/dapr-agents/agents-evaluator-optimizer.png" width=600 alt="Diagram showing how the evaluator-optimizer pattern works">
 
 **Use Cases:**
 - Content creation requiring adherence to specific style guidelines
@@ -344,7 +344,7 @@ Moving to the far end of the agentic spectrum, the Durable Agent pattern represe
 
 Enterprise applications often need durable execution and reliability that go beyond in-memory capabilities. Dapr's `DurableAgent` class helps you implement autonomous agents with the reliability of workflows, as these agents are backed by Dapr workflows behind the scenes. The `DurableAgent` extends the basic `Agent` class by adding durability to agent execution.
 
-<img src="/images/dapr-agents/agents-stateful-llm.png" width=800 alt="Diagram showing how the durable agent pattern works">
+<img src="/images/dapr-agents/agents-stateful-llm.png" width=600 alt="Diagram showing how the durable agent pattern works">
 
 This pattern doesn't just persist message history – it dynamically creates workflows with durable activities for each interaction, where LLM calls and tool executions are stored reliably in Dapr's state stores. This makes it ideal for production environments where reliability is critical.
 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md

@@ -10,7 +10,7 @@ description: "Get started with Dapr Agents through practical step-by-step exampl
 
 #### Before you begin
 
-- [Set up your local Dapr environment]({{< ref "install-dapr-cli.md" >}}).
+- [Set up your local Dapr environment]({{% ref "install-dapr-cli.md" %}}).
 
 
 ## Quickstarts

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-why.md

@@ -32,7 +32,7 @@ Dapr Agents builds on Dapr's Workflow API, which represents each agent as an act
 
 ### Data-Centric AI Agents
 
-With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic [PDF extraction]({{< ref "/developing-applications/dapr-agents/dapr-agents-integrations.md" >}}) to large-scale database interactions, it enables data-driven AI workflows with minimal code changes. Dapr's [bindings](https://docs.dapr.io/developing-applications/building-blocks/bindings/bindings-overview/) and [state stores](https://docs.dapr.io/reference/components-reference/supported-state-stores/), along with MCP support, provide access to numerous data sources for agent data ingestion.
+With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic [PDF extraction]({{% ref "/developing-applications/dapr-agents/dapr-agents-integrations.md" %}}) to large-scale database interactions, it enables data-driven AI workflows with minimal code changes. Dapr's [bindings](https://docs.dapr.io/developing-applications/building-blocks/bindings/bindings-overview/) and [state stores](https://docs.dapr.io/reference/components-reference/supported-state-stores/), along with MCP support, provide access to numerous data sources for agent data ingestion.
 
 ### Accelerated Development
 

daprdocs/content/en/reference/components-reference/supported-middleware/middleware-sentinel.md

@@ -60,7 +60,7 @@ Special note to `resource` field in each rule's definition. In Dapr, it follows
 POST/GET/PUT/DELETE:Dapr HTTP API Request Path
 ```
 
-All concrete HTTP API information can be found from [Dapr API Reference]{{% ref "api" %}}. In the above sample config, the `resource` field is set to **POST:/v1.0/invoke/nodeapp/method/neworder**.
+All concrete HTTP API information can be found from [Dapr API Reference]({{% ref "api" %}}). In the above sample config, the `resource` field is set to **POST:/v1.0/invoke/nodeapp/method/neworder**.
 
 ## Dapr configuration