LangGraph Server --> Agent Server

Author: katmayb

src/docs.json

@@ -865,7 +865,7 @@
                   {
                     "group": "Releases & changelogs",
                     "pages": [
-                      "langsmith/langgraph-server-changelog",
+                      "langsmith/agent-server-changelog",
                       "langsmith/release-versions"
                     ]
                   },
@@ -1187,7 +1187,7 @@
                       "group": "Deployment components",
                       "pages": [
                         "langsmith/components",
-                        "langsmith/langgraph-server",
+                        "langsmith/agent-server",
                         "langsmith/data-plane",
                         "langsmith/control-plane"
                       ]
@@ -1670,6 +1670,14 @@
     {
       "source": "oss/javascript/langchain/OUTPUT_PARSING_FAILURE",
       "destination": "oss/javascript/langchain/errors/OUTPUT_PARSING_FAILURE"
+    },
+    {
+      "source": "/langsmith/langgraph-server",
+      "destination": "/langsmith/agent-server"
+    },
+    {
+      "source": "/langsmith/langgraph-server-changelog",
+      "destination": "/langsmith/agent-server-changelog"
     }
   ]
 }

src/langsmith/add-auth-server.mdx

@@ -270,7 +270,7 @@ You've successfully built a production-ready authentication system for your Lang
 
 1. Set up an authentication provider (Supabase in this case)
 2. Added real user accounts with email/password authentication
-3. Integrated JWT token validation into your LangGraph server
+3. Integrated JWT token validation into your Agent Server
 4. Implemented proper authorization to ensure users can only access their own data
 5. Created a foundation that's ready to handle your next authentication challenge 🚀
 

src/langsmith/add-human-in-the-loop.mdx

@@ -133,7 +133,7 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
 </Tabs>
 
 <Accordion title="Extended example: using `interrupt`">
-  This is an example graph you can run in the LangGraph API server.
+  This is an example graph you can run in the Agent Server.
   See [LangSmith quickstart](/langsmith/deployment-quickstart) for more details.
 
   ```python {highlight={7,13}}
@@ -171,7 +171,7 @@ To review, edit, and approve tool calls in an agent or workflow, use LangGraph's
   2. Any JSON serializable value can be passed to the @[`interrupt`] function. Here, a dict containing the text to revise.
   3. Once resumed, the return value of `interrupt(...)` is the human-provided input, which is used to update the state.
 
-  Once you have a running LangGraph API server, you can interact with it using
+  Once you have a running Agent Server, you can interact with it using
   [LangGraph SDK](/langsmith/langgraph-python-sdk)
 
     <Tabs>

src/langsmith/langgraph-server-changelog.mdx renamed to src/langsmith/agent-server-changelog.mdx

@@ -1,9 +1,9 @@
 ---
-title: LangGraph Server changelog
-sidebarTitle: LangGraph Server changelog
+title: Agent Server changelog
+sidebarTitle: Agent Server changelog
 ---
 
-[LangGraph Server](/langsmith/langgraph-server) is an API platform for creating and managing agent-based applications. It provides built-in persistence, a task queue, and supports deploying, configuring, and running assistants (agentic workflows) at scale. This changelog documents all notable updates, features, and fixes to LangGraph Server releases.
+[Agent Server](/langsmith/agent-server) is an API platform for creating and managing agent-based applications. It provides built-in persistence, a task queue, and supports deploying, configuring, and running assistants (agentic workflows) at scale. This changelog documents all notable updates, features, and fixes to Agent Server releases.
 
 <a id="2025-10-31"></a>
 ## v0.5.0

src/langsmith/agent-server.mdx

@@ -0,0 +1,59 @@
+---
+title: Agent Server
+---
+
+LangSmith Deployment's **Agent Server** offers an API for creating and managing agent-based applications. It is built on the concept of [assistants](/langsmith/assistants), which are agents configured for specific tasks, and includes built-in [persistence](/oss/langgraph/persistence#memory-store) and a **task queue**. This versatile API supports a wide range of agentic application use cases, from background processing to real-time interactions.
+
+Use Agent Server to create and manage [assistants](/langsmith/assistants), [threads](/oss/langgraph/persistence#threads), [runs](/langsmith/assistants#execution), [cron jobs](/langsmith/cron-jobs), [webhooks](/langsmith/use-webhooks), and more.
+
+<Tip>
+**API reference**<br></br>
+For detailed information on the API endpoints and data models, refer to the [API reference docs](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html).
+</Tip>
+
+To use the Enterprise version of the Agent Server, you must acquire a license key that you will need to specify when running the Docker image. To acquire a license key, [contact our sales team](https://www.langchain.com/contact-sales).
+
+You can run the Enterprise version of the Agent Server on the following LangSmith [platform](/langsmith/platform-setup) options:
+
+- [Cloud](/langsmith/cloud)
+- [Hybrid](/langsmith/hybrid)
+- [Self-hosted](/langsmith/self-hosted)
+
+## Application structure
+
+To deploy an Agent Server application, you need to specify the graph(s) you want to deploy, as well as any relevant configuration settings, such as dependencies and environment variables.
+
+Read the [application structure](/langsmith/application-structure) guide to learn how to structure your LangGraph application for deployment.
+
+## Parts of a deployment
+
+When you deploy Agent Server, you are deploying one or more [graphs](#graphs), a database for [persistence](/oss/langgraph/persistence), and a task queue.
+
+### Graphs
+
+When you deploy a graph with Agent Server, you are deploying a "blueprint" for an [Assistant](/langsmith/assistants).
+
+An [Assistant](/langsmith/assistants) is a graph paired with specific configuration settings. You can create multiple assistants per graph, each with unique settings to accommodate different use cases
+that can be served by the same graph.
+
+Upon deployment, Agent Server will automatically create a default assistant for each graph using the graph's default configuration settings.
+
+<Note>
+We often think of a graph as implementing an [agent](/oss/langgraph/workflows-agents), but a graph does not necessarily need to implement an agent. For example, a graph could implement a simple
+chatbot that only supports back-and-forth conversation, without the ability to influence any application control flow. In reality, as applications get more complex, a graph will often implement a more complex flow that may use [multiple agents](/oss/langchain/multi-agent) working in tandem.
+</Note>
+
+### Persistence and task queue
+
+Agent Server leverages a database for [persistence](/oss/langgraph/persistence) and a task queue.
+
+[PostgreSQL](https://www.postgresql.org/) is supported as a database for Agent Server and [Redis](https://redis.io/) as the task queue.
+
+If you're deploying using [LangSmith cloud](/langsmith/cloud), these components are managed for you. If you're deploying Agent Server on your [own infrastructure](/langsmith/self-hosted), you'll need to set up and manage these components yourself.
+
+For more information on how these components are set up and managed, review the [hosting options](/langsmith/platform-setup) guide.
+
+## Learn more
+
+- [Application Structure](/langsmith/application-structure) guide explains how to structure your application for deployment.
+- The [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html) provides detailed information on the API endpoints and data models.

src/langsmith/api-ref-control-plane.mdx

@@ -3,7 +3,7 @@ title: Control plane API reference for LangSmith Deployment
 sidebarTitle: Control plane API
 ---
 
-The control plane API is part of [LangSmith Deployment](/langsmith/deployments). With the control plane API, you can programmatically create, manage, and automate your [LangGraph Server](/langsmith/langgraph-server) deployments—for example, as part of a custom CI/CD workflow.
+The control plane API is part of [LangSmith Deployment](/langsmith/deployments). With the control plane API, you can programmatically create, manage, and automate your [Agent Server](/langsmith/agent-server) deployments—for example, as part of a custom CI/CD workflow.
 
 <Card title="API Reference" href="https://api.host.langchain.com/docs" icon="book">
   View the full Control Plane API reference documentation

src/langsmith/assistants.mdx

@@ -19,9 +19,9 @@ Assistants are a [LangSmith](/langsmith/home) concept. They are not available in
 
 Assistants build on the LangGraph open source concept of [configuration](/oss/langgraph/graph-api#runtime-context).
 
-While configuration is available in the open source LangGraph library, assistants are only present in [LangSmith](/langsmith/home). This is due to the fact that assistants are tightly coupled to your deployed graph. Upon deployment, LangGraph Server will automatically create a default assistant for each graph using the graph's default configuration settings.
+While configuration is available in the open source LangGraph library, assistants are only present in [LangSmith](/langsmith/home). This is due to the fact that assistants are tightly coupled to your deployed graph. Upon deployment, Agent Server will automatically create a default assistant for each graph using the graph's default configuration settings.
 
-In practice, an assistant is just an _instance_ of a graph with a specific configuration. Therefore, multiple assistants can reference the same graph but can contain different configurations (e.g. prompts, models, tools). The LangGraph Server API provides several endpoints for creating and managing assistants. See the [API reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref/) and [this how-to](/langsmith/configuration-cloud) for more details on how to create assistants.
+In practice, an assistant is just an _instance_ of a graph with a specific configuration. Therefore, multiple assistants can reference the same graph but can contain different configurations (e.g. prompts, models, tools). The LangSmith Deployment API provides several endpoints for creating and managing assistants. See the [API reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref/) and [this how-to](/langsmith/configuration-cloud) for more details on how to create assistants.
 
 ## Versioning
 

src/langsmith/cicd-pipeline-example.mdx

@@ -93,7 +93,7 @@ The workflow includes:
 
     ![Agent Deployment Revision Workflow](./images/cicd-new-lgp-revision.png)
 
-- **Testing and evaluation workflow**: In addition to the more traditional testing phases (unit tests, integration tests, end-to-end tests, etc.), the pipeline includes [offline evaluations](/langsmith/evaluation-concepts#offline-evaluation) and [LangGraph dev server testing](/langsmith/local-server) because you want to test the quality of your agent. These evaluations provide comprehensive assessment of the agent's performance using real-world scenarios and data.
+- **Testing and evaluation workflow**: In addition to the more traditional testing phases (unit tests, integration tests, end-to-end tests, etc.), the pipeline includes [offline evaluations](/langsmith/evaluation-concepts#offline-evaluation) and [Agent dev server testing](/langsmith/local-server) because you want to test the quality of your agent. These evaluations provide comprehensive assessment of the agent's performance using real-world scenarios and data.
 
     ![Test with Results Workflow](./images/cicd-test-with-results.png)
 
@@ -207,12 +207,12 @@ Example `langgraph.json`:
 
 ### Local development and testing
 
-![LangGraph Studio CLI Interface](./images/cicd-studio-cli.png)
+![Studio CLI Interface](./images/cicd-studio-cli.png)
 
 First, test your agent locally using [Studio](/langsmith/studio):
 
 ```bash
-# Start local development server with LangGraph Studio
+# Start local development server with Studio
 langgraph dev
 ```
 

src/langsmith/cli.mdx

@@ -3,7 +3,7 @@ title: LangGraph CLI
 sidebarTitle: LangGraph CLI
 ---
 
-**LangGraph CLI** is a command-line tool for building and running the [LangGraph API server](/langsmith/langgraph-server) locally. The resulting server exposes all API endpoints for runs, threads, assistants, etc., and includes supporting services such as a managed database for checkpointing and storage.
+**LangGraph CLI** is a command-line tool for building and running the [Agent Server](/langsmith/agent-server) locally. The resulting server exposes all API endpoints for runs, threads, assistants, etc., and includes supporting services such as a managed database for checkpointing and storage.
 
 ## Installation
 
@@ -74,7 +74,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
         | <span style={{ whiteSpace: "nowrap" }}>`dockerfile_lines`</span> | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
         | <span style={{ whiteSpace: "nowrap" }}>`checkpointer`</span>   | Configuration for the checkpointer. Contains a `ttl` field which is an object with the following keys: <ul><li>`strategy`: How to handle expired checkpoints (e.g., `"delete"`).</li><li>`sweep_interval_minutes`: How often to check for expired checkpoints (integer).</li><li>`default_ttl`: Default time-to-live for checkpoints in **minutes** (integer); applied to newly created checkpoints/threads only (existing data is unchanged). Defines how long checkpoints are kept before the specified strategy is applied.</li></ul> |
         | <span style={{ whiteSpace: "nowrap" }}>`http`</span>            | HTTP server configuration with the following fields: <ul><li>`app`: Path to custom Starlette/FastAPI app (e.g., `"./src/agent/webapp.py:app"`). See [custom routes guide](/langsmith/custom-routes).</li><li>`cors`: CORS configuration with fields for `allow_origins`, `allow_methods`, `allow_headers`, etc.</li><li>`configurable_headers`: Define which request headers to exclude or include as a run's configurable values.</li><li>`disable_assistants`: Disable `/assistants` routes</li><li>`disable_mcp`: Disable `/mcp` routes</li><li>`disable_meta`: Disable `/ok`, `/info`, `/metrics`, and `/docs` routes</li><li>`disable_runs`: Disable `/runs` routes</li><li>`disable_store`: Disable `/store` routes</li><li>`disable_threads`: Disable `/threads` routes</li><li>`disable_ui`: Disable `/ui` routes</li><li>`disable_webhooks`: Disable webhooks calls on run completion in all routes</li><li>`mount_prefix`: Prefix for mounted routes (e.g., "/my-deployment/api")</li></ul> |
-        | <span style={{ whiteSpace: "nowrap" }}>`api_version`</span>     | _(Added in v0.3.7)_ Which semantic version of the LangGraph API server to use (e.g., `"0.3"`). Defaults to latest. Check the server [changelog](/langsmith/langgraph-server-changelog) for details on each release. |
+        | <span style={{ whiteSpace: "nowrap" }}>`api_version`</span>     | _(Added in v0.3.7)_ Which semantic version of the LangGraph API server to use (e.g., `"0.3"`). Defaults to latest. Check the server [changelog](/langsmith/agent-server-changelog) for details on each release. |
     </Tab>
     <Tab title="JS">
     | Key                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
@@ -85,7 +85,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
         | <span style={{ whiteSpace: "nowrap" }}>`node_version`</span>     | Specify `node_version: 20` to use LangGraph.js.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
         | <span style={{ whiteSpace: "nowrap" }}>`dockerfile_lines`</span> | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
         | <span style={{ whiteSpace: "nowrap" }}>`checkpointer`</span>   | Configuration for the checkpointer. Contains a `ttl` field which is an object with the following keys: <ul><li>`strategy`: How to handle expired checkpoints (e.g., `"delete"`).</li><li>`sweep_interval_minutes`: How often to check for expired checkpoints (integer).</li><li>`default_ttl`: Default time-to-live for checkpoints in **minutes** (integer); applied to newly created checkpoints/threads only (existing data is unchanged). Defines how long checkpoints are kept before the specified strategy is applied.</li></ul> |
-        | <span style={{ whiteSpace: "nowrap" }}>`api_version`</span>     | _(Added in v0.3.7)_ Which semantic version of the LangGraph API server to use (e.g., `"0.3"`). Defaults to latest. Check the server [changelog](/langsmith/langgraph-server-changelog) for details on each release. |
+        | <span style={{ whiteSpace: "nowrap" }}>`api_version`</span>     | _(Added in v0.3.7)_ Which semantic version of the LangGraph API server to use (e.g., `"0.3"`). Defaults to latest. Check the server [changelog](/langsmith/agent-server-changelog) for details on each release. |
     </Tab>
 </Tabs>
 
@@ -281,7 +281,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
 
     _(Added in v0.3.7)_
 
-    You can pin the API version of the LangGraph server by using the `api_version` key. This is useful if you want to ensure that your server uses a specific version of the API.
+    You can pin the API version of the Agent Server by using the `api_version` key. This is useful if you want to ensure that your server uses a specific version of the API.
     By default, builds in Cloud deployments use the latest stable version of the server. This can be pinned by setting the `api_version` key to a specific version.
 
     ```json
@@ -314,7 +314,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
 
     _(Added in v0.3.7)_
 
-    You can pin the API version of the LangGraph server by using the `api_version` key. This is useful if you want to ensure that your server uses a specific version of the API.
+    You can pin the API version of the Agent Server by using the `api_version` key. This is useful if you want to ensure that your server uses a specific version of the API.
     By default, builds in Cloud deployments use the latest stable version of the server. This can be pinned by setting the `api_version` key to a specific version.
 
     ```json