Sign in
Developers
DEVELOPERS

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.

Start free trialExplore 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
Ticket TriageSUPPORT
/** An agent to de-duplicate incoming GitHub issues. */import { guildTools, llmAgent, pick } from "@guildai/agents-sdk";import { gitHubTools } from "@guildai-services/guildai~github";
import systemPrompt from "./system-prompt.md"
const description = `This agent determines if a newly reported GitHubissue is a duplicate of another issue.
Given a GitHub repository (i.e., *owner* and *repo*) and the newlyreported issue (e.g., an issue number in the repository), the agentwill search the issue database to determine if the newly reportedissue duplicates another already-reported issue. If so, the agentwill mark the new issue as a duplicate of the existing issue.`;
const github = llmAgent({  identifier: "issue-deduplicator",  description,  tools: {    ...pick(gitHubTools, [      "github_list_repository_issues",      "github_list_issue_comments",      "github_get_issue",      "github_update_issue",      "github_create_issue_comment",      "github_add_issue_labels",      "github_search_issues",    ]),    ...guildTools,  },  systemPrompt,});
export default github;
PR Code ReviewDEVOPS
"use agent"
import { ExperimentalCodingTools as codingTools } from "@guildai-services/guildai~experimental-coding"import { gitHubTools } from "@guildai-services/guildai~github"import { type Task, agent, consoleTools, pick, userInterfaceTools } from "@guildai/agents-sdk"import { CONTAINER_IMAGE, codingAgentToolsFrom } from "@guildai/guildai~sys-experimental-coding"import { default as codingAgent } from "@guildai/guildai~sys-experimental-coding/tool"import Mustache from "mustache"import { z } from "zod"
import instructions from "./instructions.md"import setup from "./setup.md"
const inputSchema = z.object({  action: z.string(),  pull_request: z.object({ number: z.number() }),  repository: z.object({ name: z.string() }),  organization: z.object({ login: z.string() }),})
const tools = {  ...codingTools,  ...consoleTools,  ...pick(userInterfaceTools, ["ui_notify"]),  github_pulls_get: gitHubTools["github_pulls_get"],  communicate: codingAgent,}
const description = `Expert code reviewer that analyzes pull requests for securityvulnerabilities, performance issues, code quality, and best practices.`
export default agent({  description,  inputSchema,  outputSchema: z.object({ type: z.literal("text"), text: z.string() }),  tools,  run,})
Root Cause AnalysisOPS
import { guildTools, llmAgent, pick } from "@guildai/agents-sdk";import { newrelicTools } from "@guildai-services/guildai~newrelic";
const systemPrompt = `You are a NewRelic logs expert. Your job is to helpusers query, search, and analyze logs stored in NewRelic.
## Core Responsibilities1. **Query Logs**: Search for specific log entries using NRQL2. **Analyze Patterns**: Identify patterns, errors, and anomalies3. **Time-based Analysis**: Query logs across different time ranges4. **Filter and Aggregate**: Filter logs by attributes and aggregate data`;
const description = `Query and analyze logs from NewRelic using natural language.This agent helps you search NewRelic logs, identify patterns, troubleshootissues, and analyze log data across your infrastructure.`;
export default llmAgent({  description,  tools: {    ...newrelicTools,    ...pick(guildTools, ["guild_credentials_request"]),  },  systemPrompt,});
On-Call ResponseINCIDENT
"use agent";
import {    type Task, agent, guildTools, pick,    userInterfaceTools, progressLogNotifyEvent,} from "@guildai/agents-sdk";import { slackTools } from "@guildai-services/guildai~slack";import { z } from "zod";
const inputSchema = z.object({    slackChannelId: z.string().describe("The incident Slack channel ID"),    incidentStartedAt: z.string().describe("ISO 8601 timestamp"),});
const outputSchema = z.object({    summary: z.string(),    currentStatus: z.enum(["investigating", "mitigating", "monitoring"]),    customerImpact: z.string(),    actionsTaken: z.array(z.string()),    nextSteps: z.array(z.string()),    slackMessagesAnalyzed: z.number(),    formattedMessage: z.string().describe("Ready-to-post Slack mrkdwn"),});
const tools = {    ...pick(slackTools, [        "slack_conversations_history",        "slack_conversations_replies",    ]),    ...guildTools,    ...userInterfaceTools,};
const description = `Summarizes incident progress from a Slack channel.Given an incident channel ID and start time, fetches history using abudget-capped bookend strategy, produces a structured LLM summary,and returns a ready-to-post Slack mrkdwn message.`;
export default agent({    description,    inputSchema,    outputSchema,    tools,    run,});
Slack BotCOMMS
import {  type AgentResult, type Task, agent, callTools,  guildTools, output, pick,} from "@guildai/agents-sdk";import { slackTools } from "@guildai-services/guildai~slack";import { z } from "zod";
const llmTools = {  ...pick(slackTools, [    "slack_get_conversation_replies",    "slack_get_user_info",    "slack_get_message_permalink",  ]),  ...pick(guildTools, ["guild_credentials_request"]),};
const tools = {  ...llmTools,  ...pick(slackTools, [    "slack_post_message",    "slack_add_reaction",    "slack_remove_reaction",  ]),};
const SYSTEM_PROMPT = `You are a helpful assistant integrated intoSlack via @mention. You help users with general questions andengineering tasks.`;
export default agent({  description: `A general-purpose Slack assistant that respondsto @mentions. Handles questions, code lookups, and issuemanagement for Guild workspaces.`,  stateSchema: z.object({    stage: z.enum(["reacting_working", "fetching_thread",      "llm_working", "posting_response", "reacting_done"]),    channel: z.string(),    ts: z.string(),  }),  tools,  start: async (input, task) => {    const { channel, ts } = parseWebhookPayload(input.text);    return callTools([{      type: "tool-call",      toolName: "slack_add_reaction",      input: { channel, name: "space_invader", timestamp: ts },    }]);  },});
Tech SupportKNOWLEDGE
import { guildTools, llmAgent, pick } from "@guildai/agents-sdk";import { gitHubTools } from "@guildai-services/guildai~github";
const systemPrompt = `You are a friendly, helpful assistant that answersquestions about a codebase hosted on GitHub. Your audience is non-technical.
## How to answer1. **Start by exploring.** Use GitHub tools to read the README, browse   the directory tree, search the code.2. **Use plain language.** Avoid jargon.3. **Give concrete answers.** Count them and list them.4. **When you're unsure, say so.**5. **Keep it short.** Lead with the answer.`;
const description = `Answers plain-language questions about a codebaseby reading the code on GitHub. Designed for non-technical stakeholders.`;
export default llmAgent({  description,  tools: {    ...pick(gitHubTools, [      "github_repos_get",      "github_repos_get_readme",      "github_repos_get_content",      "github_git_get_tree",      "github_search_code",      "github_issues_list_for_repo",      "github_pulls_list",      "github_repos_list_releases",    ]),    ...pick(guildTools, ["guild_get_me", "guild_credentials_request"]),  },  systemPrompt,});

Ticket Triage

Incoming support tickets automatically classified by urgency, routed to the right team, and enriched with context from your codebase.

JiraSlack
Try agent

PR Code Review

Every pull request gets automated risk flagging — security vulnerabilities, breaking changes, performance regressions.

GitHubBitbucket
Try agent

Root Cause Analysis

When an incident fires, the agent traces it back through logs, recent deploys, and code changes — then surfaces the probable root cause.

New RelicSlackJira
Try agent

On-Call Response

PagerDuty alert → automatic context gathering → suggested remediation → human approval → action. Reduce MTTR without reducing oversight.

SlackJiraGitHub
Try agent

Slack Bot

File tasks from Slack threads. Convert conversations into actionable tickets, track decisions, and keep everyone aligned automatically.

SlackJiraGitHub
Try agent

Tech Support

Search docs, answer questions. Pull from your knowledge base, Confluence, and internal wikis to resolve support tickets faster.

ConfluenceSlack
Try agent

Ticket Triage

Incoming support tickets automatically classified by urgency, routed to the right team, and enriched with context from your codebase.

JiraSlack
Try agent

PR Code Review

Every pull request gets automated risk flagging — security vulnerabilities, breaking changes, performance regressions.

GitHubBitbucket
Try agent

Root Cause Analysis

When an incident fires, the agent traces it back through logs, recent deploys, and code changes — then surfaces the probable root cause.

New RelicSlackJira
Try agent

On-Call Response

PagerDuty alert → automatic context gathering → suggested remediation → human approval → action. Reduce MTTR without reducing oversight.

SlackJiraGitHub
Try agent

Slack Bot

File tasks from Slack threads. Convert conversations into actionable tickets, track decisions, and keep everyone aligned automatically.

SlackJiraGitHub
Try agent

Tech Support

Search docs, answer questions. Pull from your knowledge base, Confluence, and internal wikis to resolve support tickets faster.

ConfluenceSlack
Try agent

Ticket Triage

Incoming support tickets automatically classified by urgency, routed to the right team, and enriched with context from your codebase.

JiraSlack
Try agent

PR Code Review

Every pull request gets automated risk flagging — security vulnerabilities, breaking changes, performance regressions.

GitHubBitbucket
Try agent

Root Cause Analysis

When an incident fires, the agent traces it back through logs, recent deploys, and code changes — then surfaces the probable root cause.

New RelicSlackJira
Try agent

On-Call Response

PagerDuty alert → automatic context gathering → suggested remediation → human approval → action. Reduce MTTR without reducing oversight.

SlackJiraGitHub
Try agent

Slack Bot

File tasks from Slack threads. Convert conversations into actionable tickets, track decisions, and keep everyone aligned automatically.

SlackJiraGitHub
Try agent

Tech Support

Search docs, answer questions. Pull from your knowledge base, Confluence, and internal wikis to resolve support tickets faster.

ConfluenceSlack
Try agent

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

Scaffolding ticket-triage...
✓ Created project
✓ Installed dependencies
✓ Ready
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

Starting ephemeral session...
✓ Agent loaded
✓ Tools connected (3)
✓ Session ready

> Triage TICKET-4821
Classifying... P1 (production)
Routing to: platform-team
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

Saving ticket-triage...
✓ Validated
✓ Published to Agent Hub
✓ Live

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";
Learn more about pre-built tool sets for building Guild agents
See all tool sets

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.

Explore docs

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.

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

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

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.

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

Ready to manage agents at scale?

Explore our platform.

BuildDeployGovernShare

One control plane.
Manage the complete agent lifecycle.

Get a working agent in minutes.
No credit card required.

Start free trialExplore docs