> For the complete documentation index, see [llms.txt](https://docs.paradime.io/app-help/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.paradime.io/app-help/products/dino-ai/programmable-agents/triggering-from-bolt.md).

# Triggering from Bolt

A Programmable Agent can be invoked in two ways:

* **From the Paradime API** — using `triggerDinoaiAgentRun`. See API Reference.
* **From a Bolt schedule** — using the **Run Paradime DinoAI Agent** command type. This page.

Use Bolt when you want the agent to run on a **cron schedule**, **after another schedule completes**, on a **PR merge**, or as part of a Turbo CI run. Use the API when you want to embed agent runs in a workflow you orchestrate yourself (Airflow, Lambda, webhooks, etc.).

***

#### Prerequisites

* A programmable agent definition committed to your repository under `.dinoai/agents/<name>.yml`. See YAML Configuration.
* API credentials with **DinoAI Agent** capabilities, set as Bolt Schedule environment variables:
  * `PARADIME_API_ENDPOINT`
  * `PARADIME_API_SECRET`
  * `PARADIME_API_KEY`

***

#### Option 1 — Configure from the Bolt UI

In the Bolt schedule editor, click **Add command** and pick **Run Paradime DinoAI Agent**:

1. **Agent Name** — pick the agent from the dropdown. The list is populated from `.dinoai/agents/*.yml` on the configured git branch.
2. **Task** — describe the task you want the agent to complete. This becomes the agent's opening user message.
3. **Save Command**, then configure the trigger type (cron, on-merge, on-completion, etc.) and deploy.

See the full UI walkthrough at Bolt Command Settings → Run Paradime DinoAI Agent.

***

#### Option 2 — Configure from schedules-as-code YAML

The UI just writes a `paradime dinoai` CLI invocation into the schedule's `commands:` list. If you manage your Bolt schedules with YAML, add the same command directly:

```yaml
schedules:
  - name: nightly data quality
    description: "Nightly DinoAI sweep over staging models"
    owner_email: data-team@acme.io
    environment: production
    git_branch: main
    commands:
      - paradime dinoai --agent=data-quality-checker --message="Audit all staging models for missing tests and post a summary to #data-quality-alerts"
    schedule: "0 2 * * *"
    timezone: UTC
```

The arguments mirror the UI fields:

| UI field   | CLI flag             | Notes                                                                                                   |
| ---------- | -------------------- | ------------------------------------------------------------------------------------------------------- |
| Agent Name | `--agent=<name>`     | Must match an existing `.dinoai/agents/<name>.yml` on the schedule's git branch.                        |
| Task       | `--message="<task>"` | The agent's opening user message. Use a single quoted string; both single- and double-quotes are valid. |

See Configuration Reference for the full schedule YAML schema.

***

#### Lifecycle of a Bolt-triggered run

```mermaid
sequenceDiagram
    participant B as Bolt run
    participant CLI as paradime dinoai
    participant API as Paradime API
    participant P as Agent pod

    B->>CLI: paradime dinoai --agent X --message "..."
    CLI->>API: triggerDinoaiAgentRun()
    API->>P: Spawn agent pod
    loop poll
        CLI->>API: dinoaiAgentRun()
        API-->>CLI: status + messages
    end
    P-->>CLI: COMPLETED / FAILED
    CLI-->>B: exit 0 / exit 1
```

* **Fresh session per run.** Each Bolt run starts a **new** agent session — there is no continuity from one schedule run to the next. Use the API with `sendDinoaiAgentMessage` if you need multi-turn continuity.
* **Bolt waits for the agent.** The CLI blocks until the agent reaches a terminal state (`COMPLETED` or `FAILED`) and exits with the corresponding exit code. The Bolt run therefore inherits the agent's success/failure.
* **Logs.** The agent's messages stream into the Bolt command's stdout, so they show up in the Bolt run logs (and in the live log stream when polled via the SDK).
* **Notifications.** Slack notifications configured inside the agent YAML still fire — independently from any Bolt notifications configured on the schedule itself.

#### Related

* [Bolt Command Settings → Run Paradime DinoAI Agent — UI walkthrough](/app-help/products/bolt/creating-schedules/command-settings/paradime-dinoai-agent-trigger.md)
* [Schedules as Code → Configuration Reference — full YAML schedule schema](/app-help/products/bolt/creating-schedules/schedules-as-code.md)
* [API Reference — invoking agents via GraphQL](/app-help/developers/graphql-api/examples/dinoai-programmable-agents-api.md)
* [API Reference — invoking agents via Paradime SDK](/app-help/developers/python-sdk/modules/dinoai-programmable-agents.md)
* [API Reference — invoking agents via Paradime CLI](/app-help/developers/paradime-cli/dinoai-cli.md)
* [YAML Configuration — authoring the agent itself](/app-help/products/dino-ai/programmable-agents/yaml-configuration.md)
* [Tools Reference — what the agent can do once it's running](/app-help/products/dino-ai/programmable-agents/tools-reference.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.paradime.io/app-help/products/dino-ai/programmable-agents/triggering-from-bolt.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.