Production-ready agents, by design.

Code-first. TypeScript SDK. Full control.

Guild gives you a TypeScript SDK, a CLI, typed I/O, scoped integrations, and full session tracing. You write the agent. Guild handles versioning, credentials, deployment, and observability.

Book a demo Explore docs

What engineers get

Everything needed to build, test, and ship agents to production.

TypeScript SDK

@guildai/agents-sdk. Typed inputs and outputs via Zod. Three agent types for any complexity level. Sandboxed execution.

CLI

Scaffold, test, and deploy agents from your terminal. Perfect for automation workflows and CI/CD pipelines.

Typed I/O

Define inputs and outputs with Zod schemas. Type safety from IDE to production. No runtime surprises.

Scoped Integrations

Import typed tool sets for Jira, Slack, GitHub, and more. Agents request credentials at runtime through Guild.

Session Tracing

Every agent run produces a full trace. Inputs, outputs, tool calls, token usage, and latency — all captured automatically.

Versioning and Rollback

Git-backed versioning for every agent. Publish, roll back, and diff versions with a single command.

Guild Agents in practice

Typed tools. Scoped integrations. No hardcoded API keys, no credential management in your code. You define what the agent does; Guild's control plane handles credentials, permissions, versioning, and observability.

Explore our SDK docs

Workflow

From idea to production in four steps

1. Initialize
   Create a new agent from the CLI. Pick a template (LLM, state machine, or blank). Guild scaffolds the project, sets up the repo, and pulls starter files.

   $ guild agent init \  
       --name ticket-triage \  
       --template LLM
   

2. Build
   Write your agent in TypeScript. Import the tools you need. Define typed I/O with Zod. Or fork a starter agent and customize it.

   export default llmAgent({  
     description: "Triages support tickets",  
     systemPrompt: "Classify by urgency,  
       route to the right team.",  
     tools: {  
       ...jiraTools,  
       ...slackTools,  
       ...guildTools,  
     },  
   })  
   

3. Test
   Run your agent in an ephemeral session. Interactive chat, full trace output, no side effects. Iterate until it works.

   $ guild agent test --ephemeral  
   

4. Deploy
   Save, validate, publish. Your agent is live in the Agent Hub. Other teams - internal or external - can discover it, install it, or fork it.

   $ guild agent save \  
       --message "v1" \  
       --wait --publish  
   

Integrations

Tools for the services you already use

Import typed tool sets. Agents request credentials at runtime through Guild. API keys are never exposed.

GitHub

import {  
  gitHubTools  
} from "@guildai-services/guildai~github";  

Slack

import {  
  slackTools  
} from "@guildai-services/guildai~slack";  

Azure

import {  
  azureTools  
} from "@guildai-services/guildai~azure";  

Figma

import {  
  figmaTools  
} from "@guildai-services/guildai~figma";  

Jira

import {  
  jiraTools  
} from "@guildai-services/guildai~jira";  

BitBucket

import {  
  bitbucketTools  
} from "@guildai-services/guildai~bitbucket";  

Linear

import {  
  linearTools  
} from "@guildai-services/guildai~linear";  

Confluence

import {  
  confluenceTools  
} from "@guildai-services/guildai~confluence";  

New Relic

import {  
  newRelicTools  
} from "@guildai-services/guildai~newrelic";  

Cypress

import {  
  cypressTools  
} from "@guildai-services/guildai~cypress";  

TestRail

import {  
  testRailTools  
} from "@guildai-services/guildai~testrail";  

Custom

import {  
  customTools  
} from "./tools/custom";  

What makes Guild different for developers

Agents are software artifacts

Not scripts. Not notebooks. Versioned, validated, rollbackable artifacts with typed interfaces. Same discipline you expect from any production service.

Credentials stay out of your code

Guild mediates every external call. Your agent never sees an API key. Credentials are permissioned at the org level, resolved at runtime, rotated centrally.

Fork anything, customize everything

Start from a starter agent or fork any published agent. Extend it, refine it, publish your version. The same open source workflow you already know.

Debug like a real system

Full session traces for every run. See every LLM call, every tool invocation, every decision the agent made. Not a chat log. An execution trace.

Questions? Start here.

What language is the SDK?

TypeScript. The Guild Agent SDK runs in a sandboxed environment with @guildai/agents-sdk and zod for typed schemas. No external npm packages or Node built-ins.

Can I test agents without publishing?

Yes. Run guild agent test --ephemeral to spin up a temporary session. Full interactivity, full traces, zero side effects. Publish when you're ready.

Can I use agents built with LangChain or CrewAI?

Yes. Guild deploys agents built on any framework. The SDK is one way to build. Bring whatever you already have.

What integrations are available?

GitHub, Jira, Slack, Bitbucket, Azure DevOps, Confluence, Figma, New Relic, Cypress, TestRail, and more. Each is a typed tool set you import. More shipping continuously.

Can I revert to a previous version?

Yes. Every save creates a versioned, git-backed artifact. You can view the full version history, compare changes, and manually revert if something breaks.

Where are the API docs?

The Guild Agent SDK is documented at docs.guild.ai/sdk. This marketing site also publishes its own OpenAPI spec at guild.ai/openapi.json and an MCP (Model Context Protocol) server at guild.ai/api/mcp, so agents can pull site content and request a demo without scraping HTML.

One control plane.

Manage the complete agent lifecycle.

Get a working agent in minutes.