Guild Native Agent

• A Guild Native agent is defined entirely by two Markdown files: PROMPT.md (the agent's role and instructions) and DESCRIPTION.md (a short description of what the agent does).
• There is no TypeScript, no SDK, no package.json. Guild Native agents skip the build validation step and go straight to READY on initialization.
• They are the fastest way to ship a working agent on Guild. If you can write a prompt, you can ship a Guild Native agent.
• Use Guild Native when the agent's job is essentially "be a good LLM with a clear role." Use TypeScript agents when the agent needs code, tools, and control flow.

A Guild Native agent is one of the three agent architectures Guild supports (alongside TypeScript agents and Goose agents). It is the simplest of the three: two Markdown files describe the agent, and Guild handles everything else.

The name is deliberate. "Native" here means "native to Guild" — the agent is defined in Guild's own terms rather than borrowed from an SDK or a framework. If you want the shortest possible path from "I have an idea for an agent" to "an agent is running," this is it.

The scaffold is two Markdown files

When you initialize a Guild Native agent, Guild scaffolds:

my-agent/├── PROMPT.md         # Agent role, behavior, and instructions├── DESCRIPTION.md    # Brief description of the agent├── README.md└── .gitignore

PROMPT.md is the agent's system prompt: what the agent is, what it does, how it should behave, any rules or examples. DESCRIPTION.md is the short description Guild uses in listings and search.

No build step

Because there is no code, there is nothing to compile and nothing to validate against a schema. Guild Native agents skip the build validation step entirely. After initialization, the agent immediately transitions to READY.

Version lifecycle is the same

Guild Native agents still go through Guild's Saved / Validated / Published version lifecycle. "Validated" in this case just means the Markdown files were uploaded and parsed cleanly. From there, publish to make the agent available to your organization.

The runtime handles LLM calls automatically

You do not choose a provider, wire up a tool, or write handler code. Guild's runtime sends PROMPT.md as the system prompt and manages the LLM interaction. If your agent needs no external tools and no code logic, that is the entire integration.

Time-to-first-agent should be minutes

Most agent platforms make you set up an SDK, write TypeScript, and manage dependencies before you can see anything work. Guild Native flips that. Write the prompt. Publish. Done. That is often all a first useful agent needs.

The prompt is the product

For a lot of agents, the interesting engineering is prompt engineering, not code. A Guild Native agent puts the prompt front and center in a file called PROMPT.md, versioned like any other artifact, edited by anyone who can edit Markdown.

Simpler is easier to govern

An agent with no code has no code to audit. When the entire agent is a prompt, security and compliance conversations become about the prompt itself rather than about arbitrary TypeScript behavior. That is often a feature.

Use Guild Native when

• The agent's job is essentially "answer questions," "write in a specific style," or "follow a defined role."
• You want to ship in minutes and iterate on the prompt over time.
• The agent does not need external tools, private APIs, or code-driven logic.
• A non-engineer should be able to update the agent's behavior by editing Markdown.

Use a TypeScript agent when

• The agent needs to call external tools, integrations, or APIs beyond what Guild's default LLM interaction provides.
• Behavior depends on data or state that has to be computed, not just described.
• You want typed inputs and outputs via the Guild SDK's inputSchema and outputSchema.

Use a Goose agent when

You already have a Goose recipe you want to run on Guild, or you want parameterized behavior in a declarative YAML file without writing TypeScript. Recipes support Jinja templating for the prompt fields.

PROMPT.md is the entire agent

The clarity of PROMPT.md is the whole game for a Guild Native agent. Structure it: role, capabilities, constraints, examples, tone. If the agent behaves poorly, the fix is almost always in PROMPT.md.

DESCRIPTION.md is for humans, not the LLM

DESCRIPTION.md shows up where humans see it: listings, search, install screens. Write it for a teammate deciding whether to install the agent, not for the model.

Guild Native is fast, not limitless

If you find yourself wanting to reach for a tool, wanting to add code, wanting typed I/O, you have outgrown the Guild Native shape. That is fine — start there, and move to a TypeScript agent when the requirements demand it.

Version everything

Even though there is no build, every save creates a new version. Use --message on guild agent save to record what changed in PROMPT.md, and you get a real changelog for the agent's behavior over time.

Guild is a control plane for AI agents, a place to build, deploy, and govern the agents your teams run in production. Guild Native agents are the fastest path from idea to shipped agent, with the same version lifecycle and governance as any other agent on the platform.

• The agent types guide covers all three agent architectures Guild supports.
• Sign in at app.guild.ai to initialize your first Guild Native agent.