Ship Better Agents Faster: LlamaAgent Templates with llamactl (A Practical, Opinionated Guide).

Build a full-stack LlamaIndex agent (UI included) in minutes with llamactl templates, plus practical workflow patterns, hardening tips, and comparisons.

Scaffold a real agent app in minutes, understand what the template generated, and ship safely—UI included, opinions optional.

Why this matters (to devs and AI VPs)

We’ve all watched it happen:

VP: “Can we demo an agent next week?”
Engineer: “Sure.” (quietly opens a new repo and begins summoning twelve configuration files from the abyss)

LlamaIndex’s LlamaAgents templates (via llamactl) exist to stop that ritual.

Instead of “blank repo + vibes,” you get a working agent application scaffolded from known-good patterns—plus a clean path to run locally and deploy.

What you actually get from an agent template

llamactl init creates a new app from a template (or updates an existing one). Under the hood it uses Copier to copy/sync template files into your repo.

Two templates are explicitly documented for llamactl init today:

  • basic-ui: starter workflow + React/Vite UI
  • extraction-review: Extraction Agent + Review UI (integrates with Llama Cloud for review/correction flows)

If you omit --template, llamactl prompts you interactively.

The practical implication: your “agent app” is not just a Python file—it’s a runnable service (and, for UI templates, a front-end) with conventions that make shipping easier.

Table of contents

  1. Install + prerequisites
  2. Scaffold your first app (basic-ui)
  3. Run it locally (llamactl serve)
  4. Understand the generated project (so you can edit confidently)
  5. Real use case: Support triage agent (with actionable code)
  6. Real use case: Extraction + human review (extraction-review)
  7. Deployment shape + config tips
  8. Security & ops pitfalls to avoid
  9. Comparisons: how this differs from LangChain/LangGraph, AutoGen, CrewAI
  10. Key takeaways

1) Install + prerequisites (keep it boring, keep it reliable)

The official docs emphasize using uv for environment management in their getting started flow.
If you’re using a UI template, you’ll also need Node.js tooling (because React/Vite is real, and it has feelings). The template will guide you.

2) Scaffold your first agent app (the “hello, useful world” path)

# create a new app from the basic UI template
llamactl init --template basic-ui --dir my-agent-app

This is the documented non-interactive usage.

If you want the interactive picker:

llamactl init

Also documented.

3) Run locally with llamactl serve

Once inside the generated directory:

cd my-agent-app
llamactl serve

serve supports (at least) these options:

  • --preview (run in preview mode)
  • --no-install (skip dependency installation)

So if you know you already installed deps and you just want to run:

llamactl serve --no-install

4) What the template generated (so you can stop treating it like magic)

The configuration contract: pyproject.toml

LlamaDeploy apps are conventionally configured via a [tool.llamadeploy] section that declares things like workflows and where to find them.

A minimal example looks like:

[tool.llamadeploy]
name = "my-agent-app"

[tool.llamadeploy.workflows]
my_workflow = "my_agent_app.workflows:my_workflow"

The key detail is the "module_path:object_name" format.

The runtime model: Workflows

LlamaIndex Workflows give you a structured, step-based way to define agent logic. The docs show the canonical imports and pattern (Workflow, @step, StartEvent, StopEvent).

5) Real use case: a Support Triage Agent (actionable, not mystical)

Let’s build something teams actually ship: take a support ticket, classify it, route it, and return a response draft.

Example workflow (drop into your template’s workflow module)

from llama_index.core.workflow import Workflow, step, StartEvent, StopEvent, Context
from llama_index.core.llms import ChatMessage
from llama_index.core import Settings

# NOTE: configure Settings.llm in your app startup / environment as appropriate.

class TriageWorkflow(Workflow):
    @step
    async def classify(self, ctx: Context, ev: StartEvent) -> StopEvent:
        ticket = ev.data["ticket"]

        # Simple prompt—replace with your preferred agent/tooling patterns
        messages = [
            ChatMessage(role="system", content="You classify support tickets into: billing, bug, feature, or other."),
            ChatMessage(role="user", content=f"Ticket:\n{ticket}\n\nReturn only the label."),
        ]
        label = (await Settings.llm.achat(messages)).message.content.strip().lower()

        return StopEvent(result={"label": label})

triage_workflow = TriageWorkflow()

This matches the Workflows API structure shown in the official Workflows docs: Workflow + @step + events.

Why this pattern saves time

  • It’s testable: each step is isolated.
  • It’s observable: easier to attach logging per step.
  • It’s composable: you can insert retrieval, tools, or human review later without rewriting everything.

Calling your workflow (HTTP)

LlamaDeploy exposes workflow execution over HTTP; the docs show the /workflows/{workflow_name}/run style interface for running workflows.

A typical call shape:

curl -X POST http://localhost:4501/workflows/triage_workflow/run \
  -H "Content-Type: application/json" \
  -d '{"ticket":"My invoice was double charged this month."}'

(Your exact host/port depends on your local run output, but the workflow run route pattern is part of the LlamaDeploy surface.)

6) Real use case: Extraction + human review (extraction-review)

If you’re doing extraction where correctness matters (invoices, contracts, onboarding forms), you often want this pipeline:

extract → present → human corrects → downstream systems consume corrected output

That’s exactly what the extraction-review template is positioned for: an extraction agent plus a review UI, integrated with Llama Cloud.

Scaffold it:

llamactl init --template extraction-review --dir extraction-review-app

What we recommend in real implementations:

  • Treat the human-reviewed output as the source of truth (store it).
  • Emit diffs between model output and corrected output; mine that for evals.
  • Add schema validation before the UI step so reviewers fix meaning, not syntax.

7) Deployment shape + “don’t surprise your future self” tips

Updating templates safely

You can update an existing app to the latest version:

llamactl init --update

hat behavior is explicitly documented.

Practical tip: run updates on a branch and treat it like a dependency bump. (Because… it is.)

8) Security & ops pitfalls

1) Secrets in the repo
If the template uses .env files, keep them local. Use your platform’s secrets manager in prod.

2) Over-permissive tool execution
If you add tools (web access, file system, DB writes), scope them tightly and log every call. “Agent can do anything” is also known as “incident report generator.”

3) UI review flows need auditability
For extraction-review, store:

  • original extraction
  • corrected extraction
  • reviewer identity (or at least session)
  • timestamps
    That’s how you pass audits and debug regressions.

9) Comparisons so you can choose intentionally

LlamaAgents templates vs LangChain / LangGraph

  • LangChain is a broad framework for LLM apps and chains.
  • LangGraph focuses on graph/state-machine agent orchestration.
  • LlamaAgents templates via llamactl are more like “working app starters” for the LlamaIndex ecosystem: scaffold + run + UI (in some templates) + conventions.

Translation: LangChain/LangGraph give you building blocks; llamactl templates hand you a small building that already has doors.

LlamaAgents templates vs AutoGen / CrewAI

  • AutoGen (Microsoft) provides multi-agent conversation patterns and orchestration.
  • CrewAI provides role-based multi-agent “crews” with tasks and tools.

Those focus on agent interaction models; llamactl templates focus on shipping an application skeleton (including UI when relevant) aligned with LlamaIndex’s Workflows + deployment model.

10) Key takeaways

  • llamactl init is the fastest path to a runnable agent app (not just a script), and it’s designed to be updated over time.
  • Start with:
    • basic-ui when you need a quick demo + editable UI
    • extraction-review when humans must verify model output
  • Treat templates like dependencies: branch, update, test, merge.
  • Use Workflows to keep logic composable and avoid spaghetti-agent syndrome.
  • Don’t confuse LlamaIndex llamactl with llamactl.org (different tool, different job).

— Cohorte Team
January 12, 2026