Templates for vertical AI agents: sales, legal research and agency client desktops

Quick answer: on Orgo, a vertical agent product ships one template per vertical, such as a sales desk, a legal research desk or an agency client desktop, and launches a fresh computer from it for every customer. The template bakes in the apps, files, network rules and triggers that vertical needs. Each customer's keys live as workspace secrets in your vault, and their app sign-ins stay on their own computer.

TL;DR

• An Orgo template is one orgo.ai/v1 file that describes a whole cloud computer. Orgo builds it once into a golden snapshot, and every computer launched from it starts with the same setup (Templates).
• A vertical template is that file written for one job: the browser pages a sales agent opens, the folders and allowed sites a legal research agent works in, or the agent setup an agency hands each client.
• What stays per customer is not in the template. Secret values come from the vault of the user who launches (you, when your server launches), saved for that customer's workspace. Connected apps belong to one computer (Secrets, Connectors).
• Publishing your own template needs Scale or Enterprise. Launching one needs a paid plan (Account limits).
• A computer from your own template can't run by the hour, so it has to fit your plan's vCPU and RAM and stay within the account's 50 computers. Plan for that line early (Account limits).

You own the agent. Orgo owns the computer it runs on. New to templates? Read Orgo templates and triggers first. For the client accounts and keys around each customer, see How do you give every customer of your vertical agent its own computer?

What is a vertical agent template?

A vertical agent product is an AI agent built for one industry or role, such as sales teams, law firms or marketing agencies. A vertical agent template is the Orgo template that defines the computer that agent works on for each customer.

The template holds everything that is the same for every customer in that vertical:

Source: Template schema.

What changes per customer, and what stays in the template?

A template never contains anyone's keys. At launch, Orgo writes each declared secret that is set in the vault to /root/.env under its uppercase name, so anthropic_api_key becomes ANTHROPIC_API_KEY (Secrets). A secret can be saved account-wide or for one workspace, and a workspace value overrides an account value with the same name.

The vault that is read is the launching user's, not the customer's. Orgo looks up the declared names under the user who makes the create call, for the workspace the computer goes in. So when your server launches every customer's computer, per-customer values must be saved as your workspace secrets, one set per customer workspace. An account-wide value reaches every customer's computer. And a restricted API key without Secrets write launches the computer with none of your secrets (Secrets, API key permissions).

Connected apps are per computer. An app connected on one computer is that computer's alone, even in the same workspace, and deleting the computer signs its apps out. Apps are connected from the agent setup sheet, which opens when the computer runs Hermes, OpenClaw, Claude Code or Codex. An agent loop you run yourself does not get them automatically (Connectors).

What does a sales agent template look like?

A sales agent usually works in a browser, a CRM and email. This template opens the browser on the CRM and pings your app each weekday morning so it can hand that customer's agent its queue. If the computer runs one of the agents above, the CRM can be connected per computer through Connectors, where HubSpot and Salesforce sit behind More apps (Connectors).

One catch shapes the trigger. Every computer launched from a template runs the same trigger, and the only placeholders are {{trigger}}, {{source}}, {{time}} and {{data.KEY}} (Triggers). Template vars are filled in before the build, so they are the same for every launch too. A plain webhook action therefore sends an identical body from every customer's computer, and your app can't tell them apart. The template below declares a desk_token secret instead. Your app issues one token per customer, you save it as that customer's workspace secret, and a command action sends it with the ping.

api_version: orgo.ai/v1
name:    sales-desk@1.0.0
cpu:     2
ram:     4gb
display: 1280x800
 
secrets:
  - name: anthropic_api_key
    description: Model key for the sales agent.
    optional: true
  - name: desk_token
    description: Per-customer token your app issued, saved as a workspace secret.
 
apps:
  - name: chrome
    title: "Chrome"
    autostart:
      - run: "google-chrome-stable --no-sandbox --disable-gpu --no-first-run --no-default-browser-check https://app.hubspot.com"
        delay: 2
 
triggers:
  - name: morning-queue
    source: { type: cron, schedule: "0 8 * * 1-5" }
    actions:
      - type: command
        run: |
          [ -f /root/.env ] && . /root/.env
          [ -n "$DESK_TOKEN" ] || exit 0
          curl -fsS -X POST https://your-app.example.com/hooks/orgo \
            -H "Authorization: Bearer $DESK_TOKEN" \
            -H "Content-Type: application/json" \
            -d '{"event": "{{trigger}}", "at": "{{time}}"}'

The autostart pattern comes from the browser desktop example, where Chrome is already in the base image and needs no install step (Examples). The trigger uses the cron source and a command action, which runs as root (Triggers).

The computer's clock is UTC, so 0 8 * * 1-5 fires at 08:00 UTC on weekdays. Pick the hour for your customers' time zone. Template computers are created always-on, so the schedule keeps firing until you stop the computer (Template schema).

What does a legal research agent template look like?

A legal research agent needs a place to read matter files, a place to write memos, and tighter limits on where the computer can connect. This template seeds a folder, restricts lookups to the model API, your research source, your own app and Orgo, and tells your app whenever a new memo lands, with the same per-customer token as the sales desk.

api_version: orgo.ai/v1
name:    legal-research@1.0.0
cpu:     2
ram:     4gb
display: 1280x800
 
secrets:
  - name: anthropic_api_key
    description: Model key for the research agent.
    optional: true
  - name: desk_token
    description: Per-customer token your app issued, saved as a workspace secret.
 
files:
  /data/memos/README.txt: |
    The agent saves research memos in this folder.
 
egress_policy:
  mode: allow
  rules:
    - "api.anthropic.com"
    - "*.your-research-source.com"
    - "*.example.com"   # your app, which the trigger calls
    - "orgo.ai"         # Orgo's API, model gateway and Connectors
 
triggers:
  - name: new-memo
    source:
      type: file
      path: /data/memos
      events: [create]
    actions:
      - type: command
        run: |
          [ -f /root/.env ] && . /root/.env
          [ -n "$DESK_TOKEN" ] || exit 0
          curl -fsS -X POST https://your-app.example.com/hooks/memo \
            -H "Authorization: Bearer $DESK_TOKEN" \
            -H "Content-Type: application/json" \
            -d '{"path": "{{data.path}}"}'

Triggers run inside the computer, so they obey its egress policy. In allow mode, every lookup that matches no rule is dropped. Without the *.example.com rule (use your app's real domain), the trigger could never reach your app. The same goes for Orgo itself: only the VNC and Desktop API paths are exempt, so an agent that uses Orgo's model gateway, the computer's own ORGO_API_KEY or Connectors needs the orgo.ai rule (Triggers, Template schema). Agent setup downloads packages when it runs, so install the agent in the template's build step, or allow those domains too.

Read the egress rules carefully before you rely on them (Template schema):

• Domain rules filter DNS lookups only, and a rule matches any name that contains its second-level label. api.anthropic.com matches every name containing anthropic, and *.example.com every name containing example.
• In allow mode with at least one domain rule, only lookups are filtered, so a connection made straight to an IP address is not blocked. With only IP or CIDR rules, all other traffic is dropped.
• The VNC and Desktop API paths are always reachable, so you can still watch and drive the computer.

So with domain rules, the policy limits what the computer can resolve, not what it can reach. Treat it as a guardrail, not a compliance control. To see what a running computer is actually allowed to reach, call GET /api/computers/{id}/egress (API key permissions).

What does an agency client desktop look like?

An agency builds one agent and runs it for many clients. Here the template can stay the same for every client, and the separation comes from workspaces. The docs recommend one workspace per client, so each client's computers, agents, connected apps and secrets stay apart from your other clients (Workspaces, members and clients).

Two cautions. Despite the name, Can chat doesn't let a member chat with the agent: Orgo refuses that with 403 and workspace_read_only. And anyone who can chat with the agent, so the owner and Full access members, can ask it to use the connected apps (Connectors).

With Invoicing, which is on every paid plan, each client gets their own workspace and an API key that reaches only it. You choose whether you cover their computers or bill them monthly through a payment link in your business's name (Invoicing).

How do you launch a vertical template for a new customer?

1. Validate the file. POST /api/templates/validate has no side effects and returns 422 with the exact field for each error (Validate template).

2. Publish and build it once. Send the YAML with Content-Type: application/yaml, or the body is parsed as JSON (Templates quickstart):

   bashCopy

   curl -X POST "https://www.orgo.ai/api/templates?auto_build=true" \
     -H "Authorization: Bearer $ORGO_API_KEY" \
     -H "Content-Type: application/yaml" \
     --data-binary @sales-desk.yaml

3. Wait for the build. Poll GET /api/templates/default/sales-desk/1.0.0/build until status is ready, or failed with an error. A launch before ready returns 409 with code TEMPLATE_NOT_READY (Get build status, Create computer).

4. Create or pick the customer's workspace. You can own up to 9999 workspaces on every plan (Workspaces, members and clients).

5. Save that customer's values (their desk_token, and their model key if they bring one) as your workspace secrets for their workspace, with POST /api/secrets and its workspace_id. A client account's workspace isn't in the Settings → Secrets picker (Secrets).

6. Launch a computer in that workspace with template_ref, for example default/sales-desk@1.0.0, through POST /api/computers, using a key that has Secrets write (Create computer).

7. If the computer runs Hermes, OpenClaw, Claude Code or Codex, connect the customer's apps on it, or invite them with Full access to connect their own.

From the CLI, orgo templates validate sales-desk.yaml checks the file and orgo templates publish sales-desk.yaml --build publishes and builds it. While you iterate, ?force=true on publish replaces a version instead of returning 409.

To put the live screen inside your own product, see How to embed a live AI agent computer in your app. For client accounts, scoped keys and offboarding, see How do you give every customer of your vertical agent its own computer? For many customers at once, see How to scale AI agent computers to thousands on Orgo.

What are the limits to know?

• Publishing, building or test-running a template needs Scale or Enterprise on your own plan. Launching your own needs a paid plan and counts against the workspace owner's computer limit (Account limits).
• Plan room. Your own template can't fall back to the hour, so a computer from it must fit your plan's vCPU and RAM. Past that, the create answers 403 RAM_ADDON or VCPU_ADDON until you add capacity (Create computer).
• The 50-computer line. An account on a paid plan can have 50 computers. Past that, new computers run by the hour from credit, up to 999, and only blank computers or ones from a curated starter template (such as Hermes Agent, OpenClaw or Coding) can run by the hour. A computer from your own vertical template is refused there. Computers in a workspace a client pays for under Invoicing don't count toward the 50, but that workspace can't cost more a month than the client pays (403 CLIENT_PRICE_EXCEEDED) (Account limits).
• An account stores up to 100 templates, and publishing is limited to 10 in a burst, then 1 a second (Account limits).
• A launch never fails over a missing secret. The variable is simply absent, so check for it in your agent, as the trigger commands above do (Secrets).
• A launch that injects secrets cold-boots from the snapshot's disk instead of restoring its memory, so start programs that need the key as an app service or a terminal session's run (Secrets).
• Templates build Linux computers only (Template schema).
• People per workspace depend on the owner's plan: 5 on Free, Starter and Growth, 25 on Scale, and no limit on Enterprise unless your contract sets one (Workspaces, members and clients).

FAQ

Does Orgo ship ready-made sales or legal templates? No. Orgo's curated templates are agent setups such as Coding, OpenClaw and Hermes Agent (List curated templates). Vertical templates like the ones above are ones you write and publish yourself.

Can every customer use the same template? Yes. The template carries no one's keys, so the same ref launches for every customer. Values come from the launching user's vault, so save each customer's values as your workspace secrets for their workspace, and launch with a key that has Secrets write (Secrets). Your own template can't run by the hour, so it stays within your plan's room and the account's 50 computers.

How does my app know which customer a trigger came from? Not from the template alone, since every computer launched from it runs the same trigger. Give each customer a token as a workspace secret and send it from a command action, as in the sales example.

Are a customer's connected apps shared with other computers? No. A connection belongs to one computer, even in the same workspace (Connectors).

How do I ship a change to a vertical template? Publish a new version, for example sales-desk@1.1.0, and launch new computers from that ref. Publishing different content under an existing version returns 409 (Orgo templates and triggers).

Can I restrict where a legal research computer connects? Partly, with egress_policy. Domain rules filter lookups only, so a connection by IP address is not blocked. Allow your own app's domain and orgo.ai too, or your triggers and Orgo calls fail (Template schema).

Related

• Orgo templates and triggers
• How do you give every customer of your vertical agent its own computer?
• How to embed a live AI agent computer in your app
• How to scale AI agent computers to thousands on Orgo
• Bring your own proxy for an Orgo computer's browser
• What is computer use?

Sources

• Templates, Template schema, Triggers, Secrets, Templates quickstart
• Account limits, API key permissions, Create computer
• Connectors, Workspaces, members and clients, Invoicing