Skip to main content
An AI agent in Alpha is a set of model-driven steps you describe in words. Alpha writes it as real code for an agent framework, proves it works, and draws it on the Agent tab. If you want an app feature that calls a model, such as a smart search, describe the app instead: Alpha builds that as ordinary app code. To run an agent that’s already built, see Try your agent.

What does Alpha build?

Every agent is one folder, /workspace/<name>, called the agent tree. At its root, definition.yaml names the workers, their steps and order, the inputs and the fields of the answer, and tools/ holds the Python functions the steps call. Alpha’s agent compiler, Stormlight, turns that description into a project for a framework, in its own folder inside the tree. It’s plain framework code you own and can run anywhere. Open any of it from Files. Ask for more than one (“also write it for LangGraph”) and each framework gets its own folder in the same tree. Try it lets you pick which one a message runs on.

Ask for an agent

Say “agent” in so many words, in your first message or later in a session. Alpha goes by your words, not by what the task seems to need. “An app for real estate agents” and “no agents, just a CRUD app” land in the last row too. Alpha will:
  1. Ask about the agent’s shape and inputs, unless your message already says.
  2. Say the plan back in one sentence: the framework, the steps and their order.
  3. Draw the agent on the Agent tab while it is still being proved.
  4. Prove it, including one live run on your key, and publish it.

Answer the question card

When the shape is open, the agent shows one question card before writing anything: two or three questions, recommended option first. Pick an option or type into Something else…, then click Send answers. Skip — let the agent decide takes every recommendation, and “just build it” in your message skips the card. The plan sentence names every default it assumed. Once the agent is published, it may ask once whether you want a small page around it. Declining ends the matter.

How Alpha proves the agent

Every agent goes through five stages before it’s published. A failing stage names the field to change, and the agent fixes it and proves again. The graph appears on the Agent tab as soon as the description is valid, marked as not proved, so you can read it during the proof.
1

Check the description

Every worker, step, input and tool the description names exists, and the answer has a defined shape.
2

Check the code against it

Seven gate checks confirm the generated project matches the description, among them agents listed, tools bound, settings reaching the model, the answer’s shape enforced, inputs declared.
3

Run it on a stand-in model

The real tools run under a local stand-in for the model. No key and no cost. This catches a project that passes its checks but can’t run.
4

Run it live

The agent calls the real model on your key and must return the answer it promised. This is the only stage that costs money.
5

Seal it

Every framework folder carries a current proof and nothing has changed since. A hand edit inside a framework folder counts as a change, so it stops here. The proved agent is published to the Agent tab.
Once the agent is proved live and published, a card asks Test this agent with evals?. Nothing runs until you say yes: see Set up evals.

Add the keys it needs

The live run reads the key the description names, usually OPENAI_API_KEY. The agent looks for it in your secrets by name, confirms an OpenAI key with one tiny request, and tells you which model and key it is building on. Another provider’s key, such as ANTHROPIC_API_KEY for the Claude Agent SDK, is checked by the live run itself. A Lyzr agent also needs LYZR_API_KEY. With no model key, or no Lyzr key for a Lyzr agent, it asks: “This agent needs a live OpenAI key to prove it works. Add one now?” For a Lyzr agent, the question names Lyzr.
Never paste a key into a message: it lands in the transcript and the agent’s context. Keys are never written into the agent tree or a commit. The live proof spends on your key, and so does every message in Try it.

Change the agent

Ask the agent. It edits the tree’s root, redraws the graph, proves every framework folder again and republishes. Don’t edit a generated framework folder by hand: the next build rewrites it.

What can’t an agent do yet?

Turn the agent builder off

Building agents is a skill, Agent builder, that ships with Alpha. Click Skills in the sidebar and, on the Installed tab, switch its row off, or open it and turn off Installed in your sessions. That changes your sessions only. With it off, an attempt to build stops with “stormlight is off for this session (switch on the agent-builder skill in Skills)”. An agent already on the Agent tab still draws and runs. Skills that ship with Alpha covers the admin switches.
If Agent builder isn’t on your Installed tab, find it on the Explore tab and click Install. If it isn’t there either, agent building isn’t turned on for your Alpha.

Next steps

The Agent tab

Read each card, walk the flow and open any field in definition.yaml.

Try your agent

One live run per message on your own input, with each step lighting up.

Set up evals

Test cases written from your agent’s steps, priced before anything spends.

Build a support-triage agent

The whole path in one guide, from prompt to a passing eval.