# How to Move Your Grok Bot to AQ: Keep Your Bots, Routines and Memories

> Move each Grok Bot's instructions, scheduled routines and memories to AQ, then run them on the model you choose, including your own Claude or OpenAI plan.

Published November 8, 2026 · by the AQ team · Canonical: https://aq.dev/guides/move-grok-bot-to-aq/

You can move each Grok Bot to AQ by asking it to write out its instructions, its scheduled tasks and what it remembers about you, then recreating it as an AQ bot. In AQ the bot gets its own chat, routines that run on schedules and events, and a library, and it runs on the model you pick: AQ models on AQ credits, or your own connected Claude, OpenAI, Cursor or Grok subscription. Your Grok Bot keeps working while you move, so you can compare the two before turning anything off.

AQ is the multiplayer harness where teams run AI coding agents and bots together, on a machine that is theirs, with the accounts and subscriptions they connect.

This guide is the move. If you want to keep Grok Bot and let it hand coding work to AQ instead, see [Connect Grok Bot to AQ](https://aq.dev/guides/connect-grok-bot-to-aq/).

## Step 1: Save your Grok Bot's setup

Paste this prompt into each Grok Bot chat. It asks the bot to write out every bot and scheduled task it runs for you, plus what it remembers, as one JSON object in AQ's bot format. Save the reply somewhere you can copy from. Even if you stay on Grok Bot, it is a useful backup of instructions that otherwise live only inside xAI's product.

```
I'm moving my assistants to AQ. Write out every bot, agent or scheduled task you run for me as one JSON object, and reply with only that JSON.

Use exactly this shape:
{
  "bots": [
    {
      "schema": "aq-bot/v1",
      "name": "<the bot's name>",
      "role": "<one or two words, optional>",
      "description": "<one sentence>",
      "instructions": "<its full instructions, word for word>",
      "routines": [
        {
          "name": "<short name>",
          "instruction": "<what it does each time>",
          "trigger": { "kind": "schedule", "time": "07:30", "weekdays": [1, 2, 3, 4, 5], "tz": "<IANA time zone>" }
        }
      ]
    }
  ],
  "memories": [ { "text": "<one thing you remember about me>", "kind": "user" } ]
}

For a trigger that is not a time of day, write { "kind": "other", "description": "<when it runs>" }.
Memory kinds are "user", "feedback", "project" or "reference".
Never include passwords, API keys, tokens or other secrets. Leave out anything you are not sure about.
```

Read the reply before you use it. The prompt tells the bot to leave out passwords, API keys and tokens; if one appears anyway, delete it and plan to reconnect that account in AQ. A schedule that is not a time of day comes back as a plain description of when it runs, which you will turn into an AQ trigger in step 2.

## Step 2: Recreate each bot in AQ

1. **Make the bot.** In AQ choose **+** in the sidebar, then **New bot**. Give it the name and role from the JSON.
2. **Give it its instructions.** Open the bot's name to reach Bot settings and paste the `instructions` text, word for word. Bot instructions can be up to 20,000 characters.
3. **Pick its model.** In Bot settings choose the default model: an AQ model on AQ credits, or a subscription you connected in Settings, Connections. See [which models a bot can use](#models) below.
4. **Set up the routines in words.** In the bot's chat, describe each routine from the JSON, for example: `Every weekday at 07:30 Los Angeles time, brief me on unread mail and today's meetings.` The bot sets up routines from plain language, each with its own instruction and trigger. Say the time zone; if you leave it out, the bot asks.
5. **Keep what it remembered.** Paste the `memories` you want to keep into the bot's chat and ask it to save them, or add them yourself as notes in Settings, Organization, Memory. Notes are personal by default.

Repeat for each bot. Things a bot should keep at hand, like a style guide or a list of accounts it watches, can go in its library as files, pages or links.

## Step 3: Review what came over

Open the bot's Routines panel and compare it with the export. Check each trigger, time zone and instruction. For a timer routine, the panel previews the next three times it will run before you save it. A Grok Bot task that has no matching AQ trigger (see the table below) is best kept as a library note for now, or turned into a routine you run with **Run now**.

Connect the accounts the routines read. A routine on unread Gmail, a Google Calendar meeting or a Linear label reads through the routine owner's own connected account, set up in Settings, Connections. Grok's connectors do not carry over, because AQ never logs in to Grok.

## Step 4: Run each routine once as a Test

On the Routines panel, use **Test** on each routine. A Test is a live run labeled "Live test · uses credits": it runs the routine now with every outward action set to Ask, so anything that would leave AQ waits for your yes. A Test does not move the routine's event position, so the next real run still sees new mail or issues as new. Read the run's record (why it woke, what it did, what it produced, what it cost) and adjust the instruction in the chat if the result is off.

## Step 5: Turn routines on and set a monthly cap

Turn each routine on from the Routines panel. Then set the bot's monthly cap in Bot settings: it covers the AQ credits the bot's routines spend, and when the month reaches the cap the next run is skipped and you are told once. An optional ceiling stops a single run. Choose what reaches your chat per routine: only runs where something happened (the default), every run, or none.

## Step 6: Share the bot with your team (optional)

Use **Share** in the bot's header to give it to specific people or the whole team. Each member gets their own private chat with the bot, which runs as them, on their own accounts. Managers can edit the bot's instructions, routines and library. Sharing a bot needs the [AQ Pro plan](https://aq.dev/pricing/). Details are in [AQ Docs: Bots](https://aq.dev/docs/bots/).

## Grok Bot concepts and their AQ equivalents

Grok Bot details below are from [xAI's Grok Bot documentation](https://docs.x.ai/grok-bot/computer-and-apps) as of November 8, 2026.

| Grok Bot | AQ |
| --- | --- |
| A Bot with its instructions | A bot: name, role, avatar, instructions, default model. [Docs](https://aq.dev/docs/bots/) |
| Chatting with a Bot | One ongoing chat per person per bot, with threads for side discussions and Start fresh for a new context. |
| Tasks a Bot runs on its own | Routines, up to 50 per bot, each with its own instruction and trigger: a daily or weekly schedule, a monthly day, every N minutes (5 or more), a Linear label, unread Gmail, a Google Calendar meeting, GitHub events, a webhook, or Run now. |
| What a Bot remembers about you | Memory notes: personal by default, searchable by every agent, editable in Settings, Organization, Memory. [Docs](https://aq.dev/docs/memory/) |
| Files a Bot keeps on its computer | The bot's library: files, pages and links, up to 1 GB per bot and 25 MB per file. |
| Team Bots | A shared bot (AQ Pro plan): each member's chat runs as them, and who can read members' chats is a stated choice. |
| Connectors to your apps | Connected accounts per person (Gmail, Google Calendar, Slack, Linear, GitHub and more), each tool set to Allow, Ask or Off. |
| Auto Review and approvals | Needs you cards for the person whose account is used, plus per-tool Ask permissions. |
| A persistent cloud computer with a command line | A machine that is yours (an AQ sandbox or a VM in your own cloud); bots get a shell, your secrets as environment variables, and your repositories. |
| Coding through Cursor Cloud Agent controls | The bot starts work items: a branch, an isolated worktree, any coding agent or a crew, and a pull request. [Product](https://aq.dev/product/bots/) |
| Model and billing | Your pick per bot and per routine: AQ models on AQ credits at the listed per-token price, or your own connected subscription, never marked up. |
| Computer use: operating desktop apps on its computer | No AQ equivalent. AQ agents can drive a headless browser on your machine, which you can watch and take over, but they do not operate a desktop. |
| X search and Grok's built-in tools | No AQ equivalent for searching X. A bot can still browse the web and use the tools of the accounts you connect. |

## What changes for cost

- **Connected subscriptions are not marked up.** When a bot runs on your own Claude, OpenAI, Cursor or Grok account, the usage counts against that plan's own limits, and AQ adds nothing on top. [Pricing](https://aq.dev/pricing/)
- **AQ credits are priced per model.** Every AQ model shows its per-token price before you pick it. The AQ Pro plan includes $10 of AQ credits per seat each month; the Free plan includes none.
- **Routines have a monthly cap.** The bot's cap covers the AQ credits its routines spend, whoever they run as. Your own chats with a bot are your own usage, on your subscription or credits.

Related reading: [AQ Bots](https://aq.dev/product/bots/) and [how bots, routines and threads work](https://aq.dev/docs/bots/). Guides on Grok Bot usage limits and Grok Bot alternatives are coming soon.

## Frequently asked questions

### Can I export my Grok Bot?

You can ask it to write out its own setup. Paste the prompt in step 1 of this guide into each Grok Bot chat and it replies with its instructions, its scheduled tasks and what it remembers about you as one JSON object. Read the reply before you use it, and remove anything that looks like a password or key.

### Will my scheduled tasks keep running?

On Grok Bot, they keep running until you turn them off there. In AQ, each task becomes a routine you recreate in words in the bot's chat. Test each routine once, then turn it on; a routine runs as the person who created it, on their accounts.

### What happens to my Grok Bot memories?

They come out in the same export as a list of short notes. Paste the ones you want into the AQ bot's chat and ask it to save them, or add them as notes in Settings, Organization, Memory. Notes are personal by default, and every agent you use in AQ can search them.

### Can my bot keep using Grok models?

Yes, through the Grok CLI. Connect Grok in Settings, Connections with your own xAI account, then pick it as the bot's model. That usage counts against your xAI plan's own limits. You can also pick a different model per routine, such as your Claude or OpenAI subscription or an AQ model on credits.

### Is there a free way to try it?

Yes. AQ's Free plan includes bots and their routines on a personal sandbox machine, with every agent CLI signed in with your own accounts. Free includes no AQ credits, so most people connect their own Claude or OpenAI subscription. Sharing a bot with teammates needs the AQ Pro plan.

---

About AQ: AQ is the multiplayer coding harness where teams build and run bots with every AI coding agent, like Claude Code and Codex: shared live terminals, review and merge, app previews and standing jobs, in your own cloud. Start at [aq.dev](https://aq.dev/).
