adk-js from Chatbot to Agent system

The TypeScript Agent Development Kit (ADK) is an open-source toolset that enables the development, testing, and deployment of fully autonomous and controllable advanced AI agents through code. Its core features include a feature-rich toolset (e.g., Google search capabilities, custom functions), and a multi-agent hierarchy architecture for highly scalable applications, along with a visual interface for quick debugging and troubleshooting. The installation can be done by using the command npm install @google/adk.
The core benefits of using the toolkit: the ability to develop AI agents with flexible adaptability and versionable management; These agents can be deeply integrated with Google Cloud, can run in any environment from laptops to cloud servers, and can greatly speed up the development process of AI agents like regular software.

When AI starts “doing things” instead of just “answering questions”, what we need is no longer prompts, but engineering frameworks.

Google’s open-source adk-js(Agent Development Kit for JavaScript) is the product of this turning point.

Why has “Agent” become the core?

Over the past two years, the typical use paradigm for LLMs has been:

Prompt → Completion

This is true in the “Q&A, text generation” stage, but once it enters the real application scenario, the problem is immediately exposed:

• The task is multi-step
•  Requires calling an external system
•  Intermediate state is required
•  Need to be interruptible and recoverable
•  Requires maintainable

For example:

“Query data from databases→ call APIs→ analyze → generate reports → notify users”

This is no longer a “chat”, but a program execution.

Agent, which is essentially “LLM + Execution + State Machine”

What is adk-js? An engineering definition

adk-js It is a JavaScript Agent development framework launched by Google to systematically build, orchestrate, and run AI agents.

If a sentence is a little more ruthless:

It doesn’t teach you how to chat with the model, but how to use the model as a software module.

Core Design Ideas (Engineering Perspective)

Agents are first-class citizens, not prompts

In adk-js:

• Agent ≠ prompt string
• Agent = An execution unit with a lifecycle

It typically contains:

• Role Commands (System Intent)
• Tools
• Execution logic (when to continue/when to stop)
• Contextual state (state/memory)

This step elevates the LLM from a “text interface” to a “process model”.

Tools are strongly typed and verifiable

Unlike many “write tool descriptions into prompts” schemes, ADK’s Tools are:

• Clearly defined functions
• There is a parametric structure
• Verification at the code layer
• Call results can be tracked

This means:

• Agents are not “fantasy calls to APIs”
• Instead, actually call the function in your code

From an engineering perspective, this is a watershed moment in maintainability and safety.

Clear Orchestration

ADK does not assume that “one agent solves everything”.

It supports:

• Multi-agent collaboration
• Subtasks are split
• Sequence/conditional execution
• Agent → Agent call

This makes it more like:

An AI workflow engine, not a chat framework

If you’re familiar with:

• LangGraph
• State machine
• Backend task orchestration

You will understand the direction of the ADK very easily.

Runtime and State are explicit

This is where Google’s style is most obvious.

ADK emphasizes:

• Execution is traceable
• The state is structured
• Behavior is reproducible

Instead of:

• Rely on the length of the context
• Rely on prompts to pile up memory

This is critical for long-running, production-based agents.

adk-js in the entire Agent ecosystem

A visual comparison:

Frame	Engineering orientation
LangChain	Flexible, experimental
LangGraph	Strong process, community-driven
AutoGPT	The concept is leading, and the project is unstable
adk-js	Engineering priority, production-oriented

adk-js is obviously not the “fancyst”, but it’s one of the most “software infrastructure” like Agent frameworks.

Why Google?

This project comes from Google, which means one thing:

Agents are no longer community experiments, but the default form of AI applications for big tech companies.

Google is not betting on:

• “A model that is better at chatting”

Instead:

• “Agents that can be embedded in real systems and perform real tasks”

adk-js This route is the landing of the JavaScript ecosystem.

GitHub：https://github.com/google/adk-js
Tubing: