Workflow·AI & Agents·v2.1.0

AI-Q Research

Name: AI-Q Research
Author: NVIDIA

Use when asked to run deep research or AI-Q research through a reachable NVIDIA AI-Q Blueprint backend.

You say

Buy it · $15 Read it before you buy $15 Written by NVIDIA · unverified publisher

Context cost: 14.4k tokensestimated from the bundle, loaded when it triggers
Bundle: 6 files · 57.8 kB1 script among them — read before you run
Licence: Apache-2.0paid listing
Last change: —v2.1.0
Servers it uses: Noneruns standalone

What it does

Use when asked to run deep research or AI-Q research through a reachable NVIDIA AI-Q Blueprint backend.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Workflow

Runs a procedure end to end.

agentsdeep-researchnvidia

Filed under

AI & Agents

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md16.4 kB · 427 lines

--- name: aiq-research description: | Use when asked to run deep research or AI-Q research through a reachable NVIDIA AI-Q Blueprint backend. license: Apache-2.0 permissions: env: - AIQ_SERVER_URL network: - http://localhost:8000 compatibility: | Designed for Claude Code, OpenCode, Codex, and Agent Skills-compatible tools. Requires Python 3.11+ and network access to a running local AI-Q Blueprint server at `http://localhost:8000` by default. Non-local backends must be explicitly trusted by the user and granted by the host tool outside this public skill. metadata: version: "2.1.0" author: "NVIDIA AI-Q Blueprint Team <aiq-blueprint@nvidia.com>" github-url: "https://github.com/NVIDIA-AI-Blueprints/aiq" tags: - nvidia - aiq - blueprint - deep-research - research-agents - agent-skills languages: - python - bash domain: "research-agents" allowed-tools: Read Bash ---

33# AIQ Research Skill

35## Purpose

37Use this skill to call a locally running NVIDIA AI-Q Blueprint server through the helper script at

38scripts/aiq.py.

40Use this skill for research-shaped requests, including:

42- "deep research on ..."

43- "AIQ research ..."

44- "research ..."

45- "use AI-Q to answer ..."

46- "ask AI-Q about ..."

48Do not use this skill for install, deploy, start, stop, UI, CLI, Docker, Helm, or troubleshooting requests. Those

49belong to aiq-deploy.

51## Prerequisites

53Users need:

55- Python 3.11+ available as python3.

56- A reachable local or self-hosted AI-Q Blueprint backend.

57- AIQ_SERVER_URL set when the backend is not running at http://localhost:8000; non-local values must be trusted by

58 the user before any query is sent.

59- A backend configured with authentication disabled for this public helper, or a separate authenticated AI-Q skill for

60 authenticated environments.

61- Network access from the local machine to the AI-Q backend URL.

62- Credentials configured in the backend environment, not in this skill. This public helper does not collect or manage

63 API keys.

65The helper script has no third-party Python package dependencies; it uses Python standard-library HTTP modules.

67## Instructions

691. Resolve the target backend URL.

702. Run health before sending research requests.

713. If no backend is reachable, ask for a backend URL or hand off to aiq-deploy.

724. Before sending any user query, state the exact AI-Q backend URL that will receive it. For non-local URLs, continue

73 only if the user has explicitly confirmed that URL is trusted in the current conversation.

745. Poll asynchronous deep research jobs when AI-Q returns a job ID.

756. Present returned reports with citations and source URLs intact.

767. Stop on failed jobs and show the returned error; do not retry automatically.

778. After presenting a report, support follow-up: answer questions about it

78 (ask) or run a refined research pass (redo) using the same commands.

80### Step 1 - Resolve the backend

82Use AIQ_SERVER_URL when set. Otherwise try the default local backend:

84```bash

85python3 $SKILL_DIR/scripts/aiq.py health

86```

88Expected output: JSON from a reachable AI-Q health endpoint.

90If health fails and no explicit AIQ_SERVER_URL was set, ask:

92```text

93I do not see a reachable local AI-Q backend. Do you already have an AI-Q backend URL you want to use, or should I deploy a local Skill backend?

94```

96- If the user provides a URL, set AIQ_SERVER_URL for subsequent helper calls and rerun health.

97- If the user wants local deployment, hand off to aiq-deploy and preserve the original research request.

98- If a reachable backend returns 401 or 403, stop and explain that this public skill does not manage

99 authentication. Ask the user to use an authenticated AI-Q skill or configure authentication for their environment.

100- If health succeeds but /chat or /v1/jobs/async/agents fails, report that the backend is reachable but not

101 compatible with this public research flow, then offer to run aiq-deploy validation.

102

103### Step 2 - Send the routed research request

104

105Before sending the request, state the resolved endpoint:

106

107```text

108I will send this query to <AIQ_SERVER_URL>. Make sure this endpoint is trusted before sending sensitive information.

109```

110

111Do not send credentials, cookies, bearer tokens, or secret values through the query text.

112

113Run:

114

115```bash

116python3 $SKILL_DIR/scripts/aiq.py chat "<USER_QUESTION>"

117```

118

119Expected output:

120

121- A normal JSON response for shallow or direct answers.

122- Or structured JSON containing {"status": "deep_research_running", "job_id": "<JOB_ID>"} for asynchronous deep

123 research.

124

125If the response is normal JSON, present the result immediately. Do not force polling when there is no job_id.

126

127### Step 3 - Poll asynchronous jobs

128

129If the response includes deep_research_running, extract the job_id and poll with the same absolute script path:

130

131```bash

132python3 $SKILL_DIR/scripts/aiq.py research_poll <JOB_ID>

133```

134

135Expected output: the final report JSON when the job completes successfully.

136

137Use the runtime's non-blocking or background execution mechanism when available. If the chosen execution method requires

138escalated permissions, request explicit user approval first and explain why. Tell the user that deep research is running

139in the background.

140

141### Step 4 - Resume after interruptions

142

143If polling is interrupted, the job continues server-side. Resume with:

144

145```bash

146python3 $SKILL_DIR/scripts/aiq.py status <JOB_ID>

147python3 $SKILL_DIR/scripts/aiq.py report <JOB_ID>

148python3 $SKILL_DIR/scripts/aiq.py research_poll <JOB_ID>

149```

150

151Use status to inspect job status and saved artifacts. Use report when the job has already finished and you only need

152the final output. Use research_poll to keep waiting for completion.

153

154The final report may reference generated artifacts (charts, CSVs) as artifact://<id> links. To materialize them as local

155files, run python3 $SKILL_DIR/scripts/aiq.py artifacts <JOB_ID> --download-dir ./aiq-artifacts; it downloads each artifact

156and prints the local path. Do not expect base64 image data in the report itself.

157

158For a self-contained, shareable report, run python3 $SKILL_DIR/scripts/aiq.py report <JOB_ID> --out-dir ./my-report. It writes report.md plus an

159artifacts/ folder and rewrites each artifact://<id> link to the matching local file, so the report renders (charts and

160all) in any markdown viewer without a running backend.

161

162### Step 5 - Present the report

163

164When research_poll completes successfully, fetch and present the full report. Keep citations and source URLs intact.

165If the job status is failed, failure, or cancelled, show the error from the status response and ask whether the

166user wants to retry with a narrower query or different approach.

167

168### Step 6 - Follow up: ask about, edit, or redo a report

169

170After a report is presented, the user often wants to go deeper or adjust scope.

171Reuse the existing backend flow — the same auth boundary, polling, and report

172retrieval from Steps 1-5 apply; there is no separate follow-up endpoint.

173

174**Ask** — a follow-up question about a report already in hand:

175

176- For a question answerable from the report you already have, answer directly

177 from its content and citations; do not call the backend again.

178- For a question that needs new investigation, send a fresh request that carries

179 the needed context from the prior question and report into the new query

180 text, then present the new result:

181

182 ```bash

183 python3 $SKILL_DIR/scripts/aiq.py chat "<FOLLOW_UP_QUESTION> (context: <PRIOR_TOPIC>)"

184 ```

185

186 If this returns a deep_research_running job ID, poll it with research_poll

187 exactly as in Step 3.

188

189**Edit** — rewrite a report with cosmetic changes. This skill only has access

190to the data used to generate the initial report. No tools are available:

191

192```bash

193python3 $SKILL_DIR/scripts/aiq.py report_edit <JOB_ID> "<EDIT_INSTRUCTIONS>"

194```

195

196**Redo** — re-run research with adjusted scope (a narrower query, a corrected

197question, or a different depth):

198

199```bash

200python3 $SKILL_DIR/scripts/aiq.py research "<REFINED_QUERY>" [agent_type]

201```

202

203- Choose agent_type to match the desired depth (for example a deep agent for a

204 thorough pass, or shallow_researcher for a quick one); list options with

205 agents if unsure.

206- Treat a redo as a new job: state the target endpoint again before sending

207 (Step 2), then poll and present as in Steps 3-5.

208

209Do not send credentials or secret values in follow-up query text, and keep

210citations and source URLs intact in every follow-up answer.

211

212## Version Compatibility

213

214**IMPORTANT:** This skill is designed for NVIDIA AI-Q Blueprint version 2.1.0.

215

216Semantic Versioning Compatibility Rules:

217

218```text

219Skill version: X.Y.Z

220Blueprint or endpoint version: A.B.C

221

222Compatible IF:

2231. A == X (Major versions MUST match)

2242. B >= Y (Minor version must be equal or greater)

2253. C can be anything (Patch version does not affect compatibility)

226```

227

228Examples:

229

230- Skill version 2.1.0 is compatible with Blueprint version 2.1.0.

231- Skill version 2.1.0 is compatible with Blueprint version 2.2.0.

232- Skill version 2.1.0 is compatible with Blueprint version 2.1.5.

233- Skill version 2.1.0 is not compatible with Blueprint version 3.0.0.

234- Skill version 2.1.0 is not compatible with Blueprint version 2.0.0.

235

236If your Blueprint version is not compatible:

237

2381. Check for an updated skill version matching your Blueprint version.

2392. Use a Blueprint version compatible with this skill.

2403. Proceed with caution only when the user accepts the compatibility risk; API routes or response shapes may have

241 changed.

242

243## Available Scripts

244

245| Script | Purpose | Arguments |

246|---|---|---|

247| scripts/aiq.py health | Check whether the configured server responds | none |

248| scripts/aiq.py chat | POST /chat; may return inline output or a deep-research job ID | <query> |

249| scripts/aiq.py agents | List available async agent types | none |

250| scripts/aiq.py submit | Submit an explicit async job | <query> [agent_type] |

251| scripts/aiq.py research | Submit an async job, poll, and print the final report JSON | <query> [agent_type] |

252| scripts/aiq.py research_poll | Resume polling an existing async job | <job_id> |

253| scripts/aiq.py status | Fetch job status plus /state artifacts | <job_id> |

254| scripts/aiq.py state | Fetch event-store artifacts only | <job_id> |

255| scripts/aiq.py report | Fetch the final report; with --out-dir DIR, export a portable report.md + artifacts/ folder with links rewritten to local files | <job_id> [--out-dir DIR] |

256| scripts/aiq.py report_edit | Edit a completed report with cosmetic changes | <job_id> <edit_instructions> |

257| scripts/aiq.py artifacts | List durable artifacts; with --download-dir DIR, download them and print local paths | <job_id> [--download-dir DIR] |

258| scripts/aiq.py stream | Stream SSE events from a job | <job_id> |

259| scripts/aiq.py cancel | Cancel a running job | <job_id> |

260

261When the host supports a run_script() helper, call it with scripts/aiq.py and the arguments above. Otherwise, run

262the equivalent shell command, such as python3 $SKILL_DIR/scripts/aiq.py health.

263

264## Environment Variables

265

267|---|---:|---|---|

269

270## Security Best Practices

271

272- Do not put API keys, bearer tokens, cookies, or basic-auth credentials in AIQ_SERVER_URL.

273- Store backend credentials in the AI-Q deployment environment, not in this skill or command examples.

274- User query text is transmitted to the configured AIQ_SERVER_URL. Confirm the endpoint is trusted before sending

275 sensitive or confidential information.

276- Treat returned reports as potentially sensitive if the backend uses private data sources.

277- Do not truncate citations or source URLs from returned reports.

278

279## Limitations

280

281- This skill requires a running AI-Q backend; it does not deploy one.

282- The public helper does not manage authentication tokens or cookies.

283- Remote AIQ_SERVER_URL endpoints may log prompts, responses, and metadata.

284- If the backend returns HTTP 500 or lacks async agents, report the failure instead of fabricating a research answer.

285

286## Examples

287

288### Example 1: Run a routed chat or research request

289

290```bash

291python3 $SKILL_DIR/scripts/aiq.py health

292python3 $SKILL_DIR/scripts/aiq.py chat "Compare local AIQ deep research with a standard web search workflow"

293```

294

295Expected output:

296

297```text

298<health JSON from AI-Q>

299<JSON chat response or {"status": "deep_research_running", "job_id": "<JOB_ID>"}>

300```

301

302If AI-Q returns a job ID, continue with research_poll.

303

304### Example 2: Resume an existing job

305

306```bash

307python3 $SKILL_DIR/scripts/aiq.py status <JOB_ID>

308python3 $SKILL_DIR/scripts/aiq.py research_poll <JOB_ID>

309```

310

311Replace <JOB_ID> with the UUID returned by AI-Q. Expected output: status JSON followed by the report JSON when the

312job completes. If the job failed, show the returned status and do not retry automatically.

313

314### Example 3: Ask a follow-up or redo with a refined query

315

316```bash

317# Ask: a follow-up that needs new investigation, carrying prior context.

318python3 $SKILL_DIR/scripts/aiq.py chat "How does that compare on cost? (context: local AIQ deep research vs web search)"

319

320# Redo: re-run research with a narrower query and explicit depth.

321python3 $SKILL_DIR/scripts/aiq.py research "AIQ deep research cost on a single workstation" shallow_researcher

322```

323

324Expected output: a routed chat response or a new deep_research_running job ID

325to poll with research_poll. Present the follow-up answer with citations and

326source URLs intact.

327

328## References

329

330| Topic | Documentation |

331|---|---|

332| Helper script | scripts/aiq.py |

333| Deployment and backend validation | ../aiq-deploy/SKILL.md |

334

335## Common Issues

336

337### Issue: No backend is reachable

338

339**Symptoms:**

340

341- health fails with connection refused.

342- The default http://localhost:8000 URL does not respond.

343

344**Causes:**

345

346- AI-Q is not running.

347- AI-Q is running on a different host or port.

348- A local firewall or network setting blocks the connection.

349

350**Solutions:**

351

3521. Ask whether the user has an existing AI-Q backend URL.

3532. If they provide one, set it and rerun health:

354 ```bash

355 export AIQ_SERVER_URL="http://localhost:<PORT>"

356 python3 $SKILL_DIR/scripts/aiq.py health

357 ```

3583. If they want a local backend, hand off to aiq-deploy and preserve the original research request.

359

360### Issue: Backend requires authentication

361

362**Symptoms:**

363

364- Requests fail with HTTP 401 or HTTP 403.

365- The backend is reachable but rejects /chat or async job calls.

366

367**Causes:**

368

369- The backend was deployed with authentication enabled.

370- The public helper does not attach user tokens or cookies.

371

372**Solutions:**

373

3741. Stop and explain that this public skill does not manage authentication.

3752. Ask the user to use an authenticated AI-Q skill or configure their backend for this public local workflow.

3763. Rerun health and the original query only after the authentication boundary is resolved.

377

378### Issue: Health succeeds but research routes fail

379

380**Symptoms:**

381

382- health returns successfully.

383- /chat, /v1/jobs/async/agents, or polling commands fail.

384

385**Causes:**

386

387- The backend is not using an API-enabled AI-Q config.

388- The async job registry is not available in the selected backend.

389- The backend version is incompatible with this skill.

390

391**Solutions:**

392

3931. Run:

394 ```bash

395 python3 $SKILL_DIR/scripts/aiq.py agents

396 ```

3972. If agents are unavailable, report the compatibility failure and offer to run aiq-deploy validation.

3983. Confirm the deployed Blueprint version is compatible with skill version 2.1.0.

399

400### Issue: Job is interrupted or appears stuck

401

402**Symptoms:**

403

404- Local polling is interrupted.

405- The job keeps showing running.

406- Poll output shows running, but a report is returned or cancel says the job is already success.

407

408**Causes:**

409

410- Deep research is asynchronous and continues server-side.

411- Local polling output can lag behind terminal server state.

412

413**Solutions:**

414

4151. Check current state:

416 ```bash

417 python3 $SKILL_DIR/scripts/aiq.py status <JOB_ID>

418 ```

4192. If has_report: true or job_status.status: success, fetch the report:

420 ```bash

421 python3 $SKILL_DIR/scripts/aiq.py report <JOB_ID>

422 ```

4233. If the job is still running, continue polling:

424 ```bash

425 python3 $SKILL_DIR/scripts/aiq.py research_poll <JOB_ID>

426 ```

427

In the file

SKILL.md2,410 words

Files6

LicenceApache-2.0

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈230

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

14,220

on trigger

The instruction body and 5 supporting files, read only when the skill fires.

7.2%

of a 200k window

Ten skills this size would take about 72% of the window before you open a file.

050k100k150k200k context window

14.4k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

14 other skills in AI & Agents

What is in the bundle

6 files, 57.8 kB on disk. Mostly text — the instructions the model reads — with 1 script in it that your client would run only if the instructions tell it to.

BENCHMARK.md3.5 kB
SKILL.md16.4 kB
skill-card.md4.1 kB
evals/basic-product.json1.1 kB
evals/evals.json2.4 kB
scripts/aiq.py30.3 kB

What is not in it

A skill installs nothing and depends on nothing: it is a folder your client reads. This one carries 1 script beside the text, so the bundle is 6 files you can review in full before installing. The Apache-2.0 licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$15 once

AI-Q Research · Apache-2.0 · NVIDIA

one-time

Price$15 once

LicenceApache-2.0 — the author’s, unchanged by this purchase

Paid throughStripe, once, on the card you add at the checkout

Keeps workingfor good — the files are yours once they are on disk

Updatesevery release of 2.x through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are Apache-2.0, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Version2.1.0

Publishedno release date on file

Price$15

Referencenvidia/ai-q-research

Versions

v2.1.0 is what is on the shelf; no release here carries a date. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v2.1.0

No earlier releases have been published to the marketplace.

Pinning

Put nvidia/ai-q-research@2.1.0 in the install command to hold this exact version. Without the suffix you get whatever is current the day you install, and nothing moves under you afterwards.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

NVIDIA

Publishes on mcprush.

0 servers listed9 skills listednot claimed

Profile

Publisher

Servers0