chore: docs review (#55)

* chore: docs review

* docs: fix typo

---------

Co-authored-by: Alessandro Duminuco <[email protected]>

Author: keraron

docs/pages/agws/workflow_server_manager.md

@@ -1,27 +1,30 @@
-# Agent Workflow Server Manager
+# Workflow Server Manager
 
-The workflow server manager (`wfsm`) is a command line tool that streamlines the process of wrapping an agent into a container image, starting the container and exposing the agent functionality through the Agent Connect Protocol (ACP)
+The Workflow Server Manager (WFSM) is a command line tool that streamlines the process of wrapping an agent into a container image, starting the container, and exposing the agent functionality through the Agent Connect Protocol (ACP).
 
-The `wfsm` tool takes an [agent manifest](manifest.md) as input and based on it spins up a web server container exposing the agent through ACP through REST api
+The WFSM tool takes an [Agent Manifest](manifest.md) as input and based on it spins up a web server container exposing the agent through ACP through REST api.
 
-## Getting started
+## Getting Started
 
 ### Prerequisites
 
-The utility requires docker engine,  `docker` and `docker-compose` to be present on the host 
-To make sure the docker setup is correct on the host execute the 
+The utility requires Docker engine, `docker`, and `docker-compose` to be present on the host.
+
+To make sure the docker setup is correct on the host, execute the following:
+
 ```bash
 wfsm check
 ```
-command. In case the command signals error you can pass the `-v` flag to display verbose information about the failure.
+
+In case the command signals error you can pass the `-v` flag to display verbose information about the failure.
 
 ## Installation
 
-Download the release version corresponding to the host architecture from the available [release versions](https://github.com/agntcy/workflow-srv-mgr/tags), and unpack it to a folder at your convenience.
+Download the release version corresponding to the host architecture from the available [release versions](https://github.com/agntcy/workflow-srv-mgr/tags), and unpack it into a folder at your convenience.
 
 ## Run 
 
-Execute the unpacked binary - it'll output the usage string with the available flags and options. 
+Execute the unpacked binary. This outputs the usage string with the available flags and options.
 
 ```bash
 
@@ -52,17 +55,16 @@ Use "wfsm [command] --help" for more information about a command.
 
 ```
 
+## Test the Results
 
-## Test the results
-
-The exposed rest endpoints can be accessed with regular tools (curl, postman)
+The exposed rest endpoints can be accessed with regular tools (for eaxample, Curl or Postman).
 
 ## Examples
 
-Example manifests can be found in the [wfsm tool](https://github.com/agntcy/workflow-srv-mgr/examples) repository.
+Example manifests can be found in the [WFSM Tool](https://github.com/agntcy/workflow-srv-mgr/examples) repository.
 
-> Warning!
-> paths to the manifests and the paths inside the manifest definitions in the example commands need to be correct on the environment they are executed in!
+> Note:
+> Paths to the manifests and the paths inside the manifest definitions in the example commands need to be correct on the environment they are executed in!
 
 
 ### Expose the [Mail Composer](https://github.com/agntcy/acp-sdk/tree/main/examples/mailcomposer) LangGraph agent through ACP workflow server 
@@ -82,8 +84,4 @@ wfsm deploy -m examples/llama_manifest.json -e examples/env_vars.yaml
 
 ```bash
 wfsm deploy -m examples/manifest_with_deps.json -e examples/env_vars_with_deps.yaml
-```
-
-
-
-
+```

docs/pages/dir.md

@@ -1,6 +1,6 @@
 # Core Concepts
 
-ADS (Agent Directory Service) is a distributed directory service designed to
+The Agent Directory Service (ADS) is a distributed directory service designed to
 store metadata for AI agent applications. This metadata, stored as directory
 records, enables the discovery of agent applications with specific skills for
 solving various problems.
@@ -38,41 +38,41 @@ as described in [OCI digest](https://github.com/opencontainers/image-spec/blob/m
 ADS implements capability-based record discovery through a hierarchical skill
 taxonomy. This architecture enables:
 
-1. Capability Announcement
+1. Capability Announcement:
    1. Multi-agent systems can publish their capabilities by encoding them as
       skill taxonomies.
    2. Each record contains metadata describing the agent's functional abilities.
-   3. Skills are structured in a hierarchical format for efficient matching
-2. Discovery Process: The system performs a two-phase discovery operation.
+   3. Skills are structured in a hierarchical format for efficient matching.
+2. Discovery Process: The system performs a two-phase discovery operation:
    1. Matches queried capabilities against the skill taxonomy to determine
-      records by their identifier;
-   2. Identifies the server nodes storing relevant records;
-3. Distributed Resolution: Local nodes execute targeted retrievals based on
-   1. Skill matching results: Evaluates capability requirements
-   2. Server location information: Determines optimal data sources
+      records by their identifier.
+   2. Identifies the server nodes storing relevant records.
+3. Distributed Resolution: Local nodes execute targeted retrievals based on:
+   1. Skill matching results: Evaluates capability requirements.
+   2. Server location information: Determines optimal data sources.
 
 ADS uses libp2p [Kad-DHT](https://docs.libp2p.io/concepts/discovery-routing/kaddht/)
 for server and content discovery.
 
 ## Distributed Object Storage
 
-ADS (Agent Directory Service) differs from block storage systems like
-[IPFS](https://ipfs.tech/) in its approach to distributed object storage. Here's
-how:
+ADS differs from block storage systems like
+[IPFS](https://ipfs.tech/) in its approach to distributed object storage.
+The differences are described in the following sections.
 
 ### Simplified Content Retrieval
 
-1. ADS directly stores complete records rather than splitting them into blocks
-2. No special optimizations needed for retrieving content from multiple sources
-3. Records are retrieved as complete units using standard OCI protocols
+1. ADS directly stores complete records rather than splitting them into blocks.
+2. No special optimizations needed for retrieving content from multiple sources.
+3. Records are retrieved as complete units using standard OCI protocols.
 
 ### OCI Integration
 
 ADS leverages the OCI distribution specification for content storage and retrieval:
 
-1. Records are stored and transferred using OCI artifacts
-2. Any OCI distribution-compliant server can participate in the network
-3. Servers retrieve records directly from each other using standard OCI protocols
+1. Records are stored and transferred using OCI artifacts.
+2. Any OCI distribution-compliant server can participate in the network.
+3. Servers retrieve records directly from each other using standard OCI protocols.
 
 While ADS uses zot as its reference OCI server implementation, the system works
 with any server that implements the OCI distribution specification.

docs/pages/messaging_sdk/agp-core.md

@@ -10,7 +10,7 @@ established frameworks:
 
 LLMs (Large Language Models) and agent frameworks serve as middleware that
 automates processes traditionally requiring human intervention. This integration
-layer connects diverse systems and enables new automation capabilities through:
+layer connects diverse systems and enables new automation capabilities through the following:
 
 - Natural language processing
 - Contextual understanding
@@ -28,7 +28,7 @@ workflows while ensuring:
 ## Main Components
 
 Interconnecting these systems at scale requires meeting strict latency and
-response time requirements. AGP aims to provide a secure, scalable, and
+response time requirements. Agent Gateway Protocol (AGP) aims to provide a secure, scalable, and
 user-friendly communication framework that unifies state-of-the-art capabilities
 from all mentioned frameworks into a single implementation.
 

docs/pages/messaging_sdk/agp-data-plane.md

@@ -1,6 +1,6 @@
 # Data Plane
 
-The AGP data plane implements an efficient message routing and delivery system between agents.
+The Agent Gateway Protocol (AGP) data plane implements an efficient message routing and delivery system between agents.
 
 ## Message Format
 
@@ -17,28 +17,25 @@ message AgpMessage {
 
 ## Connection Table
 
-The connection table maintains agent connectivity information:
-
-- Maps channel IDs to connected agents
-- Tracks connection state and capabilities
+The connection table maintains agent connectivity information by mapping channel IDs to connected agents and tracking connection state and capabilities.
 
 ## Forwarding Table
 
-The forwarding table implements intelligent message routing:
+The forwarding table implements intelligent message routing by implementing the following:
 
-- Maps message patterns to delivery strategies
-- Supports content-based routing
-- Maintains routing metrics and preferences
-- Handles multicast and anycast delivery
+- Maps message patterns to delivery strategies.
+- Supports content-based routing.
+- Maintains routing metrics and preferences.
+- Handles multicast and anycast delivery.
 
 ## Message Buffer
 
-The message buffer provides temporary storage:
+The message buffer provides temporary storage by implementing the following:
 
-- Caches messages for reliable delivery
-- Implements store-and-forward when needed
-- Supports message deduplication
-- Handles out-of-order delivery
+- Caches messages for reliable delivery.
+- Implements store-and-forward when needed.
+- Supports message deduplication.
+- Handles out-of-order delivery.
 
 ## Data Plane Flow
 
@@ -58,8 +55,8 @@ graph LR
 
 The diagram shows the message flow through the AGP data plane components:
 
-1. Messages enter the system and are processed by the Message Buffer
-2. The Message Buffer handles deduplication and store-and-forward
-3. The Forwarding Table determines routing strategy
-4. The Connection Table manages delivery to connected agents
-5. Messages are delivered via direct, multicast, or anycast methods.
+1. Messages enter the system and are processed by the Message Buffer.
+2. The Message Buffer handles deduplication and store-and-forward.
+3. The Forwarding Table determines routing strategy.
+4. The Connection Table manages delivery to connected agents.
+5. Messages are delivered through direct, multicast, or anycast methods.

docs/pages/messaging_sdk/agp-howto.md

@@ -1,15 +1,14 @@
 # Getting Started
 
-
 ## Prerequisites
 
-To build the project and work with the code, you will need the following
-installed in your system:
+To build the project and work with the code, you need the following
+installed components in your system:
 
-### [Taskfile](https://taskfile.dev/)
+### Taskfile
 
 Taskfile is required to run all the build operations. Follow the
-[installation](https://taskfile.dev/installation/) instructions in the Taskfile
+[installation instructions](https://taskfile.dev/installation/) in the Taskfile
 documentations to find the best installation method for your system.
 
 <details>
@@ -27,44 +26,47 @@ documentations to find the best installation method for your system.
   ```
 </details>
 
+For more information, see [Taskfile](https://taskfile.dev/).
 
-### [Rust](https://rustup.rs/)
+### Rust
 
 The data-plane components are implemented in rust. Install with rustup:
 
 ```bash
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 ```
 
-### [Golang]
+For more information, see [Rust](https://rustup.rs/).
+
+### Golang
 
-The control-plane components are implemented in golang. Follow the installation
+The control-plane components are implemented in Golang. Follow the installation
 instructions in the golang website.
 
 ## Artifacts distribution
 
-### [Crates]
+### Crates
 
-See https://crates.io/users/artifacts-agntcy
+For more information, see (https://crates.io/users/artifacts-agntcy).
 
 ```bash
 cargo install agp-gw
 ```
 
-### [Container images]
+### Container Images
 
 ```bash
 docker pull ghcr.io/agntcy/agp/gw:latest
 ```
 
-### [Helm charts]
+### Helm Charts
 
 ```bash
 helm pull ghcr.io/agntcy/agp/helm/agp:latest
 ```
 
-### [Pypi packages]
+### Pypi Packages
 
 ```bash
 pip install agp-bindings
-```
+```

docs/pages/messaging_sdk/agp-session-layer.md

@@ -1,6 +1,6 @@
 # Session Layer
 
-The AGP (Agent Gateway Protocol) Session Layer manages and maintains the communication state between agents and their respective gateways. It provides essential services for establishing, maintaining, and terminating sessions between communicating entities in the AGP ecosystem.
+The Agent Gateway Protocol (AGP) Session Layer manages and maintains the communication state between agents and their respective gateways. It provides essential services for establishing, maintaining, and terminating sessions between communicating entities in the AGP ecosystem.
 
 ## Flow Diagram
 
@@ -31,17 +31,17 @@ sequenceDiagram
 
 ## Key Features
 
-- **Session Establishment**: Handles the initial handshake and connection setup
-- **State Management**: Maintains session context and state information
-- **Security**: Implements session-level security measures and token management
-- **Error Recovery**: Provides mechanisms for handling session interruptions and failures
-- **Session Termination**: Manages graceful session closure and cleanup
+- **Session Establishment**: Handles the initial handshake and connection setup.
+- **State Management**: Maintains session context and state information.
+- **Security**: Implements session-level security measures and token management.
+- **Error Recovery**: Provides mechanisms for handling session interruptions and failures.
+- **Session Termination**: Manages graceful session closure and cleanup.
 
 ## Architecture
 
-The session layer operates between the transport and presentation layers, providing a reliable communication framework for higher-level protocol operations. It ensures:
+The session layer operates between the transport and presentation layers, providing a reliable communication framework for higher-level protocol operations. It ensures the following:
 
-1. Secure session initialization
-2. Stateful communication
-3. Error handling and recovery
-4. Graceful session termination
+* Secure session initialization.
+* Stateful communication.
+* Error handling and recovery.
+* Graceful session termination.