Agent SDK Released: Define AI Agents with Markdown and TypeScript

Title

Agent SDK Released: Define AI Agents with Markdown and TypeScript

Meta Description

Agent SDK is officially released, supporting prompts written in Markdown, tools built in TypeScript, and AI agents defined in code, with optional hosted or self-hosted deployment and built-in evaluations that make every improvement measurable.

Article Content

The way AI agents are developed is undergoing a paradigm shift. The newly released Agent SDK allows developers to define agents in code, write prompts in Markdown, build tools in TypeScript, and choose hosted or self-hosted deployment. Built-in evaluation features make every change measurable, driving continuous agent iteration.

From Scattered Scripts to Engineered Development

In the past, building AI agents often meant prompts scattered across code strings, tool logic intertwined with business logic, and difficult debugging and version management. The Agent SDK breaks agents down into clear components: prompts are managed independently as Markdown files, tools are implemented as TypeScript functions, and the entire agent is defined declaratively in code.

This separation brings immediate benefits: prompts can be reviewed and modified like documentation, tool functions benefit from TypeScript's type checking, and agent configuration is brought under version control. Development teams can maintain AI agents the same way they maintain ordinary software projects.

Core Capabilities Explained

Declarative Agent Definition

Developers define an agent's role, available tools, and interaction flow through the interfaces provided by the SDK. The agent is no longer a black box, but a readable, testable code entity. This stands in sharp contrast to the traditional approach of "piling up instructions" in prompts, and the behavioral boundaries of the agent are much clearer.

Declarative is a programming paradigm opposed to imperative: imperative describes "how to execute step by step," while declarative only describes "the desired result or structure," leaving implementation details to the underlying system. In agent development, declarative definition means developers describe the agent's role, available toolset, and interaction constraints with structured configuration, rather than hand-writing scheduling logic, message assembly, and loop control. This is consistent with Kubernetes YAML manifests and React component declarations; the benefit is that configuration can be statically analyzed, serialized, and reused, and it is also easier for the SDK to uniformly inject logging, retries, and permission control at runtime. Compared with piling up natural language instructions in prompts, declaratively defined agents have clearer boundaries, are easier to test and audit, and are easier to migrate across different models.

Markdown Prompt Management

The greatest value of moving prompts into Markdown files lies in collaboration. Product managers and domain experts can directly edit Markdown to adjust agent behavior without touching TypeScript code. Prompt changes can also be tracked through the code review process, avoiding unexpected behavioral drift caused by arbitrary modifications.

TypeScript Tool Integration

Tools are the bridge through which agents interact with the outside world. Writing tools in TypeScript means full type safety and IDE support, and tool parameters, return values, and error handling can all be caught at compile time. For teams already in the TypeScript ecosystem, the integration cost is significantly reduced.

Deployment and Self-Hosting Options

The Agent SDK offers two ways to run: deploy to official hosted infrastructure, or run in your own environment. The hosted option is suitable for rapid validation and launch, saving operational burden; self-hosting meets enterprise-level needs such as data compliance and network isolation. This flexibility allows the same set of agent code to be used across different environments, avoiding migration costs caused by vendor lock-in.

Built-in Evaluation: Making Improvements Evidence-Based

The built-in evaluation feature is the key differentiator between the Agent SDK and simple wrapper libraries. After each change to prompts or tool logic, developers can run evaluations to measure changes in agent performance. Agent development thus enters a closed loop of "modify—measure—iterate," rather than tuning parameters by feel.

Evaluation data can also accumulate into regression test sets, preventing subsequent changes from breaking existing capabilities. For agent products that need long-term maintenance, this engineering capability is more valuable than a one-time performance improvement.

A regression test set originates from traditional software engineering and refers to a set of cases with fixed inputs and expected outputs, used to quickly detect "fix one place, break another" problems after each change. For AI agents, because model outputs are uncertain, evaluation usually does not pursue word-for-word comparison but instead uses graders: exact match, rule validation, keyword or structure checks, or another model acting as a judge (LLM-as-a-judge) scoring according to a rubric. A practical evaluation set should cover typical tasks, edge cases, and historical failure cases, and regularly add new problems exposed in production. Common metrics include pass rate, task completion rate, tool-call correctness rate, and average latency. The evaluation set itself also needs version management and should be included in the repository together with prompts and tool code to form a truly traceable iteration loop.

What It Means for Developers

The Agent SDK pushes AI agent development from "prompt engineering" to "software engineering." The combination of Markdown and TypeScript lowers the collaboration barrier, the dual options of hosted and self-hosted cover scenarios from personal projects to enterprise deployment, and built-in evaluation fills the missing measurement step in agent iteration. For teams productizing AI capabilities, this toolchain is worth including in technology selection evaluations.

One-line Summary

The Agent SDK defines agents declaratively in code, pushing AI agent development toward software engineering.

Paragraph Summary

The article introduces how the newly released Agent SDK transforms AI agent development from scattered scripts into engineering practice. The SDK breaks agents into three parts: prompts managed independently in Markdown, tools implemented in TypeScript, and the agent's role and interaction flow defined declaratively in code, making prompts reviewable and collaborative, tools type-safe, and configuration version-controlled. For deployment, it offers official hosting and self-hosting, balancing rapid launch with data compliance and avoiding vendor lock-in. Built-in evaluation is the core differentiator, making every prompt or tool change measurable, forming a "modify—measure—iterate" loop, and allowing evaluation data to accumulate into regression test sets. The article argues that this toolchain pushes agent development from prompt engineering to software engineering and is worth including in selection evaluations for productization teams.