Getting started

Let your AI set it up

Paste one prompt into Claude Code, Cursor, or whichever coding agent you use. It reads your repository, works out how Queuey belongs in it, and sets it up — stopping at the one step only you can do.

The prompt

Copy this into your agent, in the repository you want to connect.

Paste into your agent

Set up Queuey (https://queuey.ai) in this repository.

1. Install the CLI if it is not already there:
   dotnet tool install -g Queuey.Cli --prerelease
   (No .NET SDK? Take the standalone binary from
   https://github.com/Queuey-AI/queuey-client/releases and put it on PATH.)

2. Run:  queuey advise --json
   It reads this repository and returns: whether we send events, receive them or
   both; which path to publish by; the evidence behind each conclusion; the next
   steps; and any question it could not answer from the code.

3. Follow what it returned.
   - Tell me its reasoning in your own words, and name the files it read.
   - If it asks a question (usually: can the network here be trusted?), ask me
     before you decide. A factory, kiosk, vehicle or on-prem box usually cannot.
   - Do NOT write your own retry loop, local queue, backoff or offline buffer.
     That is Queuey.Edge, already built and maintained. If the advice points to
     Edge, use Edge.

4. Set it up:
   queuey advise --write-files     # queuey.deploy.json + a .gitignore line
   Then add the package it recommended (dotnet add package Queuey.Client, or
   Queuey.Edge), and wire up the publish call where it told you to.

5. Stop and ask me for an API key when you need one. Minting it is something I
   do in the console at https://app.queuey.ai — never you.
   Once I have given you one, you can run:  queuey advise --apply
   to create the queue.

Reference, as plain text rather than HTML: https://app.queuey.ai/llms-full.txt
Read it when you need exact syntax; do not guess at it.

What happens, in order

It reads the repository
Project files, infrastructure and source. It is looking for two things it can actually determine: whether events already survive a crash somewhere, and whether local storage survives a restart.
It works out the path
Already have an outbox, a bus or a job queue? Publish from that consumer — no reason to rebuild it. Disk that survives a restart, on a network you cannot trust? That is Queuey Edge. Otherwise, publish straight to the ingress.
It asks you the one thing it cannot read
Whether the network where this runs can be trusted. That is not in the repository, so it is asked rather than guessed — and only where the answer would change the recommendation.
It sets up, and stops at the key
It writes the deployment file and wires up publishing. Minting an API key is a console action, so it hands that back to you: a key that can mint keys turns repository access into account access.

If you would rather look first

This one analyses and changes nothing — no files, no workspace, no credentials. Useful on a repository you do not want touched yet, or when you just want to see what it makes of things.

Analyse only

Analyse this repository for Queuey (https://queuey.ai) but change nothing.

Install the CLI if needed:  dotnet tool install -g Queuey.Cli --prerelease
Then run:  queuey advise

Summarise what it says: do we send, receive or both; which path it recommends;
and the evidence it read that from. List the files it would create, but do not
create them. If it asks a question it could not answer from the code, put that
question to me.

Why it does not ask whether you send or receive

Because it can tell. queuey advise reads that from the code, along with whether you already have somewhere events survive a crash, and whether local disk survives a restart. Asking you to classify your own repository would be asking you to do the part the tool does better — especially on a codebase you inherited.

It does ask about the network, because that genuinely is not in the repository. And it shows the file behind every conclusion, so when it reads something wrong you can see exactly where and say so.

Two things the agent will not do

Mint an API key. That is a console action, and it stays yours. A key that can mint keys would turn repository access into account access.
Write its own delivery machinery. If your producer needs retries, a local buffer or offline survival, the answer is Queuey Edge, which already exists. An agent is good at writing two hundred lines of retry logic, which is exactly why it is told not to.

Without an agent

The same command works on its own, and reads more like a second opinion than a tool:

bash

queuey advise
queuey advise --json     # the same, for a machine

Or follow the quickstart and send an event by hand.