Google adds LangChain support to Agents CLI without forcing ADK

Extensions install at two scopes: project scope and user scope. The default is project scope, where the extension lives in the project's Git repo. Teammates and CI pipelines pick up the extension on every checkout. The alternative is user scope, enabled via the --global flag. User scope stores the extension in the user's home configuration directory. This scope applies to every project on the machine where the user works. The user scope is useful for framework bootstrap extensions that run before any project exists. When both scopes define the same command, the project scope wins. The agents-cli info command surfaces the source of each active command clearly. The system will not silently merge or override extensions from different scopes. Any conflict surfaces to the developer at install time or in the extension list.

The system follows the discipline of package managers like uv or npm. It resolves a Git reference to an exact commit SHA at install time. The system records the resolved SHA in a lockfile for the project. It uses the lockfile to re-materialize the exact reviewed code on every fresh checkout. The agents-cli install command restores the vendored working copy from the pinned SHA. This process guarantees that CI and local development run bit-for-bit identical code. To advance a pin to the latest commit, a developer runs agents-cli extension update. This command re-resolves the reference and re-prompts for third-party trust. The complete lifecycle is documented in the Using Extensions section of the docs. The system is marked experimental in version 1.8.0. Teams depending on it should pin their Agents CLI version to a specific tag. The manifest schema and command surface may still change in breaking ways.

The first-party LangChain extension and its structure

Google released a first-party LangChain extension as a project template. One command scaffolds a working LangChain agent wired into the Agents CLI lifecycle. The resulting project has zero google-adk dependency. It deploys to Cloud Run through the same code path an ADK project uses. The template serves all three communities: LangChain, LangGraph, and Deep Agents. Modern LangChain provides state management via the LangGraph library. The three frameworks share a common graph representation in this version. The template serves all three communities with the same code structure. A Google Cloud project with billing enabled is required to use the extension. Teams can create a billing-enabled project at console.cloud.google.com if they do not have one. If Agents CLI is not installed, it can be installed in a single command. Users must authenticate with Google Cloud and enable necessary APIs at runtime. Commands like gcloud config set project set the project ID for the agent. Teams must enable aiplatform.googleapis.com, run.googleapis.com, and artifactregistry.googleapis.com. Scaffolding and extension installation are the same operation in this workflow. Developers point agents-cli create directly at the extension's template. The command specifies the template pinned to a specific release tag like v1.8.0. The output confirms the scaffold succeeded by fetching the remote template. The scaffolded project already contains an agents-cli-extension.yaml at its root. This file is auto-loaded at project scope the next time any command is invoked. There is nothing to install manually because the project itself is the extension's installation. A developer scaffolding a LangChain project does not need to know the Extension System exists. The command looks and feels like a native agents-cli create invocation. It happens to produce a LangChain project instead of an ADK project.

Installing extensions and managing them in Git

The extension system relies on Git for version control and distribution. Developers create a directory in their Git repository to store the extension. The directory must contain the agents-cli-extension.yaml file to be valid. The file declares which built-in commands the extension overrides or adds. Extensions are distributed through Git repositories rather than a package registry. This avoids the need for a central index or a package format to maintain. Any directory inside any Git repository can serve as an extension. Git handles the versioning, pinning, and distribution of these extensions automatically. Enterprise platform teams can create an internal repository for their extensions. They point their developers at this repository without coordinating with external registries. A single Git repository can hold multiple extensions under one ownership. The fragment identifier syntax lets a repo hold several related extensions. For example, one extension handles deploy, another handles login, and another scaffolds. This shared ownership allows for a consistent release cadence across the family. Extensions install at two scopes: project scope and user scope. The default is project scope, where the extension lives in the project's Git repo. Teammates and CI pipelines pick up the extension on every checkout. The alternative is user scope, enabled via the --global flag. User scope stores the extension in the user's home configuration directory. This scope applies to every project on the machine where the user works. The user scope is useful for framework bootstrap extensions that run before any project exists. When both scopes define the same command, the project scope wins. The agents-cli info command surfaces the source of each active command clearly. The system will not silently merge or override extensions from different scopes. Any conflict surfaces to the developer at install time or in the extension list. The system follows the discipline of package managers like uv or npm. It resolves a Git reference to an exact commit SHA at install time. The system records the resolved SHA in a lockfile for the project. It uses the lockfile to re-materialize the exact reviewed code on every fresh checkout. The agents-cli install command restores the vendored working copy from the pinned SHA. This process guarantees that CI and local development run bit-for-bit identical code. To advance a pin to the latest commit, a developer runs agents-cli extension update. This command re-resolves the reference and re-prompts for third-party trust. The complete lifecycle is documented in the Using Extensions section of the docs. The system is marked experimental in version 1.8.0. Teams depending on it should pin their Agents CLI version to a specific tag. The manifest schema and command surface may still change in breaking ways.

Why this matters for enterprise teams and compliance

Enterprise admins often have governance policies they want to enforce across all teams. These policies might include a compliance scan or an SSO gate for every deploy. A Model Risk Management hop might be required before evaluations run. Implementing these requirements today often means forking the CLI or building a wrapper. The Extension System allows teams to enforce policies without forking the tool. Platform teams can create extensions that wrap deploy invocations with compliance checks. They can ensure login routes through corporate single sign-on automatically. Evaluations can flow through a Model Risk Management pipeline via extension commands. This approach avoids the permanent maintenance tax of forking the CLI. Teams do not need to hand-merge every upstream improvement into their fork. Developers can use the same command surface regardless of the underlying framework. Six commands in the CLI assume the ADK runtime: playground, run, and four eval subcommands. The other eighteen or so commands are framework-agnostic: scaffold, infra, deploy, publish, login. Without extensions, choosing a non-ADK framework for a single project meant losing access. Teams would lose access to all twenty-four commands if they did not use extensions. The Extension System handles both ADK-heavy and non-ADK projects with one mechanism. It allows a team to use LangChain for a specific project while using ADK elsewhere. This flexibility is crucial for regulated industries with strict governance needs. It prevents teams from walking away and building everything from scratch. Building from scratch consumes several engineer-months of work that the team had not planned for. The new system ensures tooling remains as polished as the upstream project.

How OpenSmartRoute helps teams manage these diverse frameworks

OpenSmartRoute is an open-source router for AI requests with a hosted platform. It sends each request to the best-fit model, agent, tool, or skill from a catalogue. The team defines the catalogue and sets weights for quality, cost, speed, and safety. Hard rules pin a request to specific constraints like on-premises models or cost caps. The router learns from outcomes so a model that answers well gets more traffic. A model that fails gets less traffic automatically. A new model is one catalogue entry and competes on the next request. Nothing else changes in the app when a new model joins the catalogue. OpenSmartRoute works with any OpenAI-compatible provider and open-weight models served locally. It supports MCP tools and A2A agents for complex workflows. A savings ledger shows what each routed request cost next to the most expensive model. An input guard spots prompt injection and personal data before a request leaves the system. The 'osr eval' command measures routing accuracy on the team's own prompts. It can fail a build if the routing accuracy drops below a set threshold. The hosted platform keeps a models catalogue with prices and public rankings. These rankings are built from real traffic data within the platform.

Teams using Agents CLI with extensions can route requests through OpenSmartRoute effectively. The router handles the diversity of frameworks like LangChain and ADK seamlessly. It ensures that compliance checks and governance policies are applied consistently. Teams can set up rules to ensure sensitive data stays on on-premises models. Cost caps prevent unexpected billing spikes when using different frameworks. The router learns which models work best for specific agent frameworks. This reduces the need for manual tuning of each framework's deployment. OpenSmartRoute provides a unified interface for managing diverse agent toolchains. It simplifies the lifecycle of deploying agents across different frameworks. The platform allows teams to compare costs and performance across all models. This visibility helps teams make data-driven decisions about their agent infrastructure. The router integrates with the Agents CLI extension system for full workflow support. Teams can enforce their own policies across every project using the extension mechanism. OpenSmartRoute ensures that the benefits of the new extension system are realized. It provides the infrastructure needed to scale diverse agent frameworks safely.

What to do when adopting the new extension system

Start by pinning your Agents CLI version to a specific release tag. The system is marked experimental in v1.8.0 and may change in breaking ways. Create an internal platform-extensions repository for your team's custom extensions. Point your developers at this repository instead of external registries. Use the agents-cli extension add command to add extensions to your projects. You can reference a local path or a remote Git repository for the extension. The # syntax lets a single Git repository hold multiple extensions. Bundle related extensions like deploy, login, and scaffold under one repo. Ensure your Google Cloud project has billing enabled for the LangChain extension. Install the necessary APIs like aiplatform.googleapis.com and run.googleapis.com. Scaffold your LangChain projects directly using the first-party extension template. The command produces a project with an auto-loaded agents-cli-extension.yaml file. Inspect the generated structure to verify the LangGraph configuration and overrides. Run your agents-cli commands to ensure the extensions work as expected. Use agents-cli info to see the source of each active command. Monitor your lockfiles to ensure CI and local development run identical code. Run agents-cli extension update to advance pins to the latest commits. Test your custom extensions with a small project before rolling them out. Document your extension policies to ensure compliance across all teams. Review the 'osr eval' metrics to ensure your routing decisions remain accurate. Keep your models catalogue updated with prices and performance rankings. Use the savings ledger to track costs across different agent frameworks.

Source: https://developers.googleblog.com/powering-the-agent-development-lifecycle-with-any-framework-from-adk-to-langchain-and-beyond/