> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orgo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Ask support

> Ask Orgo’s support agent how to do something, and get an answer with full URLs and copyable commands.

The support agent in Orgo’s help panel, for programs. A coding agent setting Orgo up for someone can ask it what to do next instead of guessing.

```bash theme={null}
curl -X POST https://www.orgo.ai/api/v1/support/ask \
  -H "Authorization: Bearer $ORGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "question": "How do I give my computer a public URL?" }'
```

The answer is markdown in `answer`. Its links are full URLs, also listed in `links`, and its code is in fenced blocks with their language.

## Follow up

Nothing is stored. To go on, send back the `messages` from the answer with your next `question`:

```json theme={null}
{
  "messages": [
    { "role": "user", "content": "How do I give my computer a public URL?" },
    { "role": "assistant", "content": "…" }
  ],
  "question": "It says PUBLIC_URLS_DISABLED. What now?"
}
```

## With a key, and without

| | With an account-wide API key | Without a key |
| - | - | - |
| Answers from the docs and pricing | Yes | Yes |
| Reads the account’s plan, billing status and computers | Yes | No |
| Hands the conversation to Orgo’s team | Yes, they reply to the account’s email | No, it points to [contact@orgo.ai](mailto:contact@orgo.ai) |

It never reads API keys, secrets, files or what is on a screen, and it changes nothing. When it hands a conversation to the team, `handoff` is `{ "status": "sent", "email": "…" }`.

A key scoped to one workspace gets `403` (`workspace_scope_mismatch`): support reads the account, so it takes an account-wide key, or no key.


## OpenAPI

````yaml POST /v1/support/ask
openapi: 3.1.0
info:
  title: Orgo API
  description: >-
    Launch cloud computers that AI agents can control and interact with. Create
    workspaces, provision computers, and control them programmatically.
  version: 2.0.0
  contact:
    name: Orgo Support
    email: spencer@orgo.ai
    url: https://orgo.ai
servers:
  - url: https://www.orgo.ai/api
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Support
    description: >-
      Orgo’s support agent, for programs: ask how to do something in Orgo and
      get an answer with full URLs and copyable commands.
  - name: Account
    description: >-
      Account capacity: how many computers an account may run, and adding or
      giving back more.
  - name: Agent accounts
    description: >-
      Accounts an AI agent makes for itself, and the claim link a person uses to
      take one over.
  - name: Clients
    description: >-
      Run Orgo for your clients from your own app: a workspace and scoped key
      each, billed to you or to them.
  - name: Workspaces
    description: Organize computers into named workspaces
  - name: Computers
    description: Provision and manage virtual computers
  - name: Computer Lifecycle
    description: Start, stop, and restart computers
  - name: Computer Actions
    description: Control mouse, keyboard, and execute commands
  - name: Screens
    description: >-
      More than one desktop on a single computer. Each screen is its own X
      server with its own cursor and window manager, so an agent working on one
      cannot disturb another.
  - name: Files
    description: Upload and download files
  - name: Templates
    description: Author, build, and launch reproducible computers from templates
  - name: Chat
    description: Run an agent on a computer through OpenAI-compatible chat completions.
paths:
  /v1/support/ask:
    post:
      tags:
        - Support
      summary: Ask Orgo’s support agent
      description: >-
        Ask Orgo’s support agent a question about using Orgo. It answers from
        Orgo’s docs, pricing and public pages, and the docs of Hermes Agent,
        OpenClaw, Claude Code and Codex, as markdown with full URLs and copyable
        commands. Send `question`, or a conversation as `messages`. To follow
        up, send back the answer’s `messages` with your next `question`. Nothing
        is stored.


        With an API key it also reads that account’s plan, billing status and
        computers (never keys, secrets, files or screens), and can hand the
        conversation to Orgo’s team, who reply to the account’s email
        (`handoff`). Without a key it answers from the docs. It changes nothing.
        Limits: 30 questions an hour per account, and 15 an hour and 40 a day
        per address without a key.
      operationId: askSupport
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                question:
                  type: string
                  maxLength: 4000
                  description: The question. Added after `messages` when both are sent.
                messages:
                  type: array
                  description: >-
                    The conversation so far, oldest first. The last 12 turns are
                    read.
                  items:
                    type: object
                    required:
                      - role
                      - content
                    properties:
                      role:
                        type: string
                        enum:
                          - user
                          - assistant
                      content:
                        type: string
            example:
              question: How do I give my computer a public URL?
      responses:
        '200':
          description: The answer.
          content:
            application/json:
              schema:
                type: object
                required:
                  - answer
                  - links
                  - handoff
                  - messages
                properties:
                  answer:
                    type: string
                    description: >-
                      Markdown. Links are full URLs; code is in fenced blocks
                      with its language.
                  links:
                    type: array
                    description: The pages the answer points to, in order.
                    items:
                      type: object
                      properties:
                        title:
                          type: string
                        url:
                          type: string
                  handoff:
                    type:
                      - object
                      - 'null'
                    description: >-
                      Set when the agent handed the conversation to Orgo’s team,
                      who reply to `email`.
                    properties:
                      status:
                        type: string
                        enum:
                          - sent
                      email:
                        type: string
                  messages:
                    type: array
                    description: >-
                      The conversation including this answer. Send it back with
                      the next `question`.
                    items:
                      type: object
                      properties:
                        role:
                          type: string
                        content:
                          type: string
              example:
                answer: >-
                  Make a key at [API
                  keys](https://www.orgo.ai/settings/developers), then create a
                  computer:


                  ```bash

                  curl -X POST https://www.orgo.ai/api/computers \
                    -H "Authorization: Bearer $ORGO_API_KEY" \
                    -H "Content-Type: application/json" \
                    -d '{"workspace_id": "YOUR_WORKSPACE_ID"}'
                  ```
                links:
                  - title: API keys
                    url: https://www.orgo.ai/settings/developers
                handoff: null
                messages:
                  - role: user
                    content: How do I create a computer with the API?
                  - role: assistant
                    content: Make a key at …
        '400':
          description: 'No question: `question_required` or `invalid_request`.'
        '401':
          description: A key was sent and is not valid.
        '403':
          description: >-
            A key scoped to one workspace (`workspace_scope_mismatch`). Use an
            account-wide key, or none.
        '429':
          description: Too many questions. `Retry-After` says when to try again.
        '502':
          description: >-
            The agent didn’t answer (`agent_failed`). Try again, or email
            contact@orgo.ai.
        '503':
          description: The agent is unavailable.
      security:
        - bearerAuth: []
        - {}
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: API key authentication. Get your key at orgo.ai/workspaces

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.