# Use GEKI from your coding agent

A coding agent such as Claude Code, Codex, or Cursor can build Company Bots for you. It is the second way next to the [Console](/guides/first-bot), and both work on the same bots. The agent lists, creates, edits, tests, and publishes bots and Knowledge Bases on your request. You do not need a GEKI account first. You can sign up during the login.

## Quickstart

Paste this into your agent:

```text
Set me up so you can build and manage my GEKI Company Bots.
Read https://docs.geki.ai/guides/your-agent.md and follow the section "For the agent".
Tell me exactly what I have to do myself.
```

The agent installs the `geki` tool and starts the login. It shows you a link and a code. Open the link, sign in or create an account, and confirm. The agent then has its own API key. You never copy a key.

Then ask for work in plain words:

- "Create a bot called Onboarding Buddy that answers new hires' questions. Test it with two questions."
- "Create a Knowledge Base from the Company wiki template and add it to Onboarding Buddy."
- "List the bots with unpublished changes. Publish Onboarding Buddy after I say yes."

The agent works on the draft. Nothing reaches your people until the bot is published. People open the published bot in [Chat](/chat).

## Step by step

This is what the agent walks you through. You can also do it yourself in a terminal.

### Install the tool

The package `geki` on PyPI is the Python client. The extra `cli` adds the `geki` command. It needs Python 3.12 or newer.

```bash
uv tool install "geki[cli]"
```

You can use `pipx install "geki[cli]"` instead.

### Log in

```bash
geki auth login
```

The tool prints a link and a code and opens your browser. On the page:

1. Sign in, or select **Create account** if you have no account yet. A new account creates its organization first and then comes back to the same page.
2. Check that the code on the page is the code in your terminal.
3. Pick the organization if you belong to more than one.
4. Tick **May publish bots** if the agent may publish. Without it, the agent changes drafts and you publish them in the Console. The box is there only when you may publish yourself.
5. Select **Confirm**.

The terminal says "Logged in to" with the organization. The key is saved in your home folder. Check it at any time:

```bash
geki auth status
```

It ends with "Key works." when the key is valid.

The key is a personal API key named "geki CLI on" and your computer's name. It can do what you can do with bots and Knowledge Bases, nothing else: use models, read, create, edit, and test bots, read and change Knowledge Bases, and publish when you ticked it. It cannot write vault credentials or change members, connections, or settings. A Viewer gets a key that only reads. The key expires after 90 days. Run `geki auth login` again then. A new login from the same computer replaces the old key.

`geki auth login --no-wait` prints the link and the code and stops. The next `geki auth status` collects the key after you confirmed. Coding agents use this form, because they stop long commands. The code is valid for 30 minutes.

### Install the skill

The tool ships a skill named `geki`. It tells a coding agent how to build, test, and publish bots with the tool and which rules to keep. Install it once per agent:

```bash
geki skill install --target claude
```

The targets are `claude` (`~/.claude/skills/geki`), `codex` (`~/.codex/skills/geki`), and `agents` (`~/.agents/skills/geki`). Add `--project` to install into the current folder instead, or use `--dir PATH` for any folder. Without a target the command lists the folders and writes nothing. Run it again after `uv tool upgrade geki` so the skill matches the tool.

An agent without skill support can read the same text with `geki skill show`.

### Commands

| Command | What it does |
| --- | --- |
| `geki auth login`, `status`, `logout` | Logs in, shows and checks the key, removes it. |
| `geki models list` | Lists the models you can use. |
| `geki bots list`, `get`, `create`, `update`, `edit` | Lists bots and reads or changes a draft. |
| `geki bots capabilities BOT` | Lists what the bot can reach and which data leaves it. |
| `geki chat BOT` | Chats with the draft. Add `--live` for the published bot, `-m "QUESTION"` to send one message and print the whole answer. |
| `geki bots publish BOT` | Publishes the draft. Asks to acknowledge new capabilities. |
| `geki bots pause BOT`, `resume BOT` | Pauses or resumes a live bot. |
| `geki bots states BOT`, `rollback BOT STATE` | Lists published versions and copies one into the draft. |
| `geki templates list`, `use` | Lists templates and creates a draft bot from one. |
| `geki skills list`, `upload` | Lists skills and uploads a skill as a zip. |
| `geki knowledge list`, `create` | Lists and creates Knowledge Bases. |
| `geki sessions list` | Lists sessions of your bots. |
| `geki skill install`, `show` | Installs the agent skill, or prints it. |
| `geki reference` | Prints every command with its options as Markdown. |

Every command has `--help`. `-o json` or `-o yaml` prints the full object. `-q` prints only ids. A bot file is YAML. The tool sends only the fields that changed.

Put `--dry-run` before a command to see what it would do. A command that writes prints the request as JSON (`method`, `path`, `body`) and sends nothing.

The bots API is in beta and can change. If a command breaks after an update, run `uv tool upgrade geki`.

## Without a browser

On a server or in CI, create a key in the Console and give it to the tool:

1. Open [console.geki.ai](https://console.geki.ai), select **API keys**, then **Create key**.
2. Enter a **Name**, tick the permissions the job needs, and choose the bots.
3. Select **Create key** and copy the key. It is shown once.

Then set the environment variable `GEKI_API_KEY`, or run `geki auth login --paste` and paste the key at the hidden prompt. The variable wins over a saved key. The base URL is `https://api.geki.ai/v1`. Set `GEKI_API_URL` only to use another one.

## Keep the key safe

The key does what its permissions allow, as you. A key that may publish can change and publish every bot you can.

- Keep keys out of git, prompts, and chat logs. Do not pass a key with `--api-key` on your own computer: it lands in your shell history.
- Confirm a login only when you started it yourself just now.
- Create one key per tool or machine. If one leaks, you revoke only that one.
- To stop a key, open **API keys** in the Console and select **Revoke** in its row actions.

## For the agent

You set up GEKI access for the user and then manage their Company Bots. "You" is the coding agent. The user is the person who sent you here.

1. Run `geki --version`. If the command is missing, install it with `uv tool install "geki[cli]"`, or with `pipx install "geki[cli]"` if there is no uv. It needs Python 3.12 or newer. If neither uv nor pipx exists, tell the user what to install and stop.
2. Install the skill for your agent: `geki skill install --target claude`, `--target codex`, or `--target agents`. If your agent has no skills, run `geki skill show` and read the output. From here, follow the skill `geki`. It holds the rules and the steps for bots, skills, triggers, and Knowledge Bases. Run `geki reference` once to see every command.
3. Run `geki auth status`. If it ends with "Key works.", go to step 5.
4. Run `geki auth login --no-wait`. Show the user the link and the code it prints and say:
   1. Open the link. Sign in, or create an account if you have none.
   2. Check that the page shows the same code.
   3. Pick the organization, tick **May publish bots** if I may publish, and select **Confirm**.

   Wait until the user says it is done. Then run `geki auth status`. It collects the key and ends with "Key works.". If it says "Waiting for you to confirm", the user has not confirmed yet. If the code expired, run `geki auth login --no-wait` again. If it fails in another way, show the user the output and help to fix it.
5. Run `geki bots list` and `geki models list`. Tell the user in two or three lines what you found and that you are ready. Suggest a first task, such as creating a small bot.

Never ask the user for an API key, never print, store, or commit one, and do not look for keys on the machine. If the user's role only reads bots, `geki bots create` fails with 403. Tell the user that an Owner or Admin can give them the Builder role. For product details read `https://docs.geki.ai/llms-full.txt`. The index is `https://docs.geki.ai/llms.txt`. Every handbook page is also Markdown: add `.md` to its URL.

A small bot file looks like this:

```yaml
name: Onboarding Buddy
model: <an id from geki models list>
purpose: Answers questions from new hires.
instructions: |
  Answer in short, plain sentences. If you do not know, say so.
starter_questions:
  - Where do I find the laptop setup guide?
```

## Next

- [Build your first Company Bot](/guides/first-bot) shows the same work in the Console.
- [Company Bots](/bots) explains access, pinning, and internet access.
- [API](/api) describes the base URL, the stable model routes, and the reference.
- [Models](/models) explains the model choice.
