Build Types & Flags

create-fetch-agent generates four project shapes, and every one ships a runnable project: unique pre-generated seeds, deterministic ports, the Agent Chat Protocol wired in, a Makefile, and a dependency manifest for your chosen package manager. This page covers each build type's layout and run commands, then the flags for non-interactive runs.

Build Types at a Glance

Build type	Wizard label	Port(s)	Run
Single agent	Single agent	8000	make run
Chat agent	Chat agent (ASI:One ready)	8000	make run
Multi-agent	Multiple agents (ASI:One routes between them)	8001+ (sequential)	make <agent>
Payment agent	Payment agent (FET)	8000	make run

Every build type speaks the chat protocol, so all of them are ASI:One-ready out of the box.

---

Single / Chat agent

A flat, self-contained agent. Chat agent and Single agent produce the same runnable, chat-enabled shape — a great starting point for a single ASI:One-ready service.

my-app/
  agent.py          # speaks the chat protocol; <name>_workflow(query) is your hook
  .env              # AGENT_SEED_PHRASE (pre-generated)
  pyproject.toml    # (uv / poetry) — or requirements.txt for pip
  Makefile          # make run
  README.md

What you get:

• The chat protocol is included and its manifest is published on startup.
• ctx.session is surfaced in the handler so you can key per-conversation state.
• The agent starts on port 8000.

Where your logic goes: the <name>_workflow(query) function in agent.py.

make run

---

Multi-agent (ASI:One routing)

Several independent agents, each an expert at one task. There is no orchestrator — every agent speaks the chat protocol and registers on Agentverse, and ASI:One discovers and routes each request to whichever agent best matches its description.

my-app/
  agents/
    __init__.py
    alice/
      __init__.py
      alice_agent.py   # independent chat agent; alice_workflow(query) is your hook
    bob/
      __init__.py
      bob_agent.py
  .env                 # one <NAME>_SEED_PHRASE per agent (pre-generated)
  Makefile             # one `make <agent>` target each
  pyproject.toml       # (uv / poetry) — or requirements.txt for pip
  README.md

What you get:

• Each agent is fully standalone, with its own seed and port (deterministic and sequential from 8001).
• An AGENT_DESCRIPTION field in each agent file — this is what ASI:One matches against to route requests, so fill it in with a specific one-line summary of what that agent does.
• No central router to build or maintain: ASI:One is the orchestrator.

Run each agent in its own terminal:

make alice

make bob

---

Payment agent (FET)

A pay-to-use agent: it speaks the chat protocol and the Agent Payment Protocol, charging in on-chain FET before running its paid action. The full request → commit → on-chain verify → complete flow is generated, with ledger verification built in.

my-app/
  agent.py                       # includes both chat + payment protocols
  protocols/
    chat_proto.py                # chat handling + run_paid_action() — your hook
    payment_proto.py             # the FET rail: request, on-chain verify, complete
  .env                           # seed (pre-generated) — no payment keys needed
  Makefile                       # make run
  README.md

What you get:

• The complete FET payment rail in a single file (protocols/payment_proto.py), including on-chain verification via cosmpy.
• No payment keys to configure — FET defaults to the stable-testnet and the wallet auto-funds itself on startup.
• run_paid_action() in protocols/chat_proto.py — the one function you own — runs automatically once a payment is verified.

make run

Then chat with the agent and pay the FET request from a testnet wallet to complete the flow.

FET only, on purpose

This template ships the FET payment rail because it's the complete, working one. Other rails (Stripe cards, USDC, etc.) are intentionally left as an extension point for you to add in protocols/payment_proto.py. For guidance on other payment methods, see the Agent Payment Protocol docs and the Fetch-skills payment skills.

---

Flags & Non-interactive Usage

Pass flags to skip prompts — handy for scripts, CI, or re-recording demos. Any prompt whose flag you omit still runs interactively.

Flag	Purpose
--type <t>	Build type: single · chat · multi · payment
--agents <list>	Multi-agent only: agent names, e.g. alice,bob
--count <n>	Multi-agent only: N agents with default names
--python <m>	Package manager: uv · poetry · pip
--ai <list>	AI-editor context: cursor,claude,antigravity,agents (or none)
--no-install	Skip installing Python dependencies
--no-register	Skip the Agentverse registration prompt
--skills-only	Add AI-editor context to an existing project (no scaffolding)
-h, --help	Show usage

Non-interactive scaffold:

npx create-fetch-agent my-bot --type payment --python uv --ai cursor --no-install

Non-interactive multi-agent:

npx create-fetch-agent squad --type multi --agents alice,bob --python uv --ai cursor

Skills-only mode

Already have a project and just want the AI-editor context? Run create-fetch-agent in place — it installs SKILL.md files without generating or touching any of your code. This is the same context Fetch-skills installs.

# inside your project, fully non-interactive
npx create-fetch-agent --skills-only --ai cursor,claude

# or target a directory and pick which protocol context to add
npx create-fetch-agent ./my-existing-agent --skills-only --type payment

--type controls which protocol context is installed — a payment project also gets the FET payment context, while the others get the chat-protocol context.

Related docs

• Overview — what create-fetch-agent is and the wizard walkthrough
• Fetch-skills — the AI-editor context installer used under the hood
• Agent Chat Protocol — wired into every generated agent
• Agent Payment Protocol — the flow behind the payment agent
• Agentverse — connect and discover your agents