GitHub Issues Backlog Agent

Automate GitHub backlog execution with a DinoAI agent that picks up Agent Ready issues, builds dbt™ models with tests and docs, opens one PR per issue, and posts progress to Slack.

Automate your analytics engineering backlog with a native DinoAI agent that reads every open GitHub issue labelled Agent Ready, implements the required dbt™ models with tests and YAML docs, opens a PR per issue and posts the link to Slack.

No custom Python, no SDK glue, no orchestrator. The agent is a single YAML file in your repo, triggered on a schedule by Bolt.

Before You Start

Paradime

• Your Paradime API endpoint, API key, and API secret. — You can generate under Workspce Settings → API. Make sure to have DinoAI agent API capabilities. Requires Admin access to generate API keys.

GitHub

• Write access to the repository you want to review PRs on

• Ability to add repository secrets and create GitHub Actions workflows

Integrations

The following must already be connected in Paradime:

• Slack — the agent posts reviews to #pr-reviews via post_slack_message

Labelling

• Issues you want automated must be open and carry the label agent-ready.

What You'll Build

By the end of this guide you'll have:

• A github-backlog-agent DinoAI agent YAML committed under .dinoai/agents/

• A Bolt schedule that triggers the agent on a cron cadence using the Run Paradime DinoAI Agent command — no scripts to maintain

What the Agent Does Per Issue

Once triggered, the agent works through the backlog and, for each open Agent Ready issue:

1. Reads the issue
2. Identifies source tables and implied metrics
3. Explores the repo to understand existing models and sources
4. Drafts staging (and mart) dbt™ models with tests and YAML docs
5. Branches + commits + pushes (gh-<number>-…)
6. Opens a PR (Closes #<number>) and posts "✅ Done: <PR URL>" to Slack

The agent never invents a column that isn't in the source. When an issue is ambiguous it surfaces explicit Open questions in the PR description rather than guessing.

Architecture Overview

How It Works

Bolt runs a single paradime dinoai command on your chosen cadence. That spins up one agent pod with a task message telling it to process the Agent Ready backlog. The agent list issues, create branch, implement each issue, push, and open a PR - then posts to Slack. Bolt blocks until the agent reaches a terminal state and inherits its success or failure, and the agent's messages stream into the Bolt run logs.

1

Create the Agent YAML

Create the following file in your repository at .dinoai/agents/github-backlog-agent.yml. This defines the agent's role, goal, tools, and Slack output channel.

.dinoai/agents/github-backlog-agent.yml

name: github-backlog-agent
version: 1

role: >
  Analytics Engineer turning GitHub issues into well-scoped dbt model PRs,
  using the gh CLI.

goal: >
  For each open GitHub issue labelled "agent-ready" — or the specific issue
  number in the trigger message: read it, implement the dbt
  models it needs (staging, plus a mart where appropriate) with tests and YAML
  docs on a new branch, open a PR that closes the issue, and post the PR link
  to Slack. One branch and one PR per issue. Skip any issue that already has an
  open PR.

backstory: >
  You never invent a column that isn't in the source. When an issue is
  ambiguous, you flag it under "Open questions" in the PR instead of guessing.
  You follow the project's dinorules conventions and implement everything
  yourself — no delegation.

tools:
  mode: allowlist
  list:
    - read_file
    - write_file
    - replace_in_file
    - search_files_and_directories
    - ripgrep_search
    - run_sql_query
    - run_terminal_command
    - post_slack_message

slack:
  channel: "#analytics-eng"

2

Commit the Agent to Your Repo

Commit the YAML to the git branch your Bolt schedule will run against (e.g. main):

git add .dinoai/agents/github-backlog-agent.yml
git commit -m "Add github-backlog-agent"
git push

The agent now appears in the Agent Name dropdown when you configure a Bolt command - the list is populated from .dinoai/agents/*.yml on the configured branch.

3

Add Paradime Credentials to the Bolt Schedule

The paradime dinoai command authenticates with your Paradime API credentials. Store them on the schedule (or at the workspace level under Workspace Settings → Environment Variables to share across all schedules):

Variable	Value
PARADIME_API_ENDPOINT	Your Paradime GraphQL endpoint
PARADIME_API_KEY	Your Paradime API key
PARADIME_API_SECRET	Your Paradime API secret

Make sure the API key has DinoAI Agent capabilities enabled (Workspace Settings → API). These are the only secrets you manage.

4

Create the Bolt Schedule

Go to Bolt → Schedules and click New Schedule. Name it something like GitHub Backlog Agent, then add a command using the Run Paradime DinoAI Agent command type.

Option 1: From the Bolt UI

Click Add command → Run Paradime DinoAI Agent, then fill in:

• Agent Name — pick github-backlog-agent from the dropdown.

• Task — the agent's opening message. For a full backlog sweep:

Find every open GitHub issue labelled agent-ready. For each one: read it, implement the required dbt models with tests and YAML docs on a new branch, open a PR with Closes #<number>.

Save Command, then set the trigger type (cron, on-merge, on-completion) and deploy.

Option 2 Schedules as Code

If you manage Bolt schedules with YAML, add the same command directly. The UI just writes a paradime dinoai invocation under commands::

schedules:
  - name: github backlog agent
    slug: github-backlog-agent-l3m4n5
    description: "Sweep open Agent Ready GitHub issues into dbt PRs"
    owner_email: [e-mail]
    environment: production
    git_branch: main
    commands:
      - >-
        paradime dinoai --agent="github-backlog-agent" --message="Find
        every open GitHub issue labelled agent-ready. For each one: read it,
        implement the required dbt models with tests and YAML docs on a new branch,
        open a PR with Closes #<number>." 
    schedule: "0 9 * * 1-5"
    timezone: UTC

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

5

Choose a Schedule Frequency

Pick the cadence that matches how often your team labels new issues as Agent Ready:

Cadence	Cron expression	When it runs
Every day at 9 AM	0 9 * * *	Monday–Sunday, 9:00 AM
Weekdays at 9 AM	0 9 * * 1-5	Monday–Friday, 9:00 AM
Once a week (Monday 9 AM)	0 9 * * 1	Every Monday, 9:00 AM
Twice a week (Mon & Thu)	0 9 * * 1,4	Monday and Thursday, 9:00 AM
Every 6 hours	0 */6 * * *	12 AM, 6 AM, 12 PM, 6 PM

For most teams, weekdays at 9 AM (0 9 * * 1-5) is a good default. If there are no Agent Ready issues, the agent reports an empty backlog and the run completes cleanly.

File Structure

The only file you author lives in your repo:

your-repo/
├── dbt_project.yml
└── .dinoai/
    └── agents/
        └── github-backlog-agent.yml

Everything else — triggering, polling, notifications — is handled natively by Bolt and the agent runtime.

Related Docs

• Programmable Agents — Quick Start — getting started with DinoAI agents

• Programmable Agents — YAML Configuration — full reference for agent config options

• Programmable Agents — Tools Reference — all available tools including read_file, get_linear_issue, and post_slack_message

• Running from Bolt — trigger agents from a Bolt schedule (UI and YAML)`

• Slack Integration — connecting Slack to Paradime

• Paradime API & Credentials — where to find your API endpoint, key, and secret