# Get started — Kogen

Get started

# Build your first feature with Kogen.

Shape the feature with an agent in the interface you prefer. Kogen carries the approved Intent through implementation, checks, independent review and a commit.

## Give this to your agent

```
Read https://kogen.dev/get-started/ and help me set up Kogen in this repository. Help me shape and refine my feature, show me the Intent for approval, then run the Build and wait for its result. Make the implementation through Kogen.
```

Use ChatGPT or another agent with command-line access. It can guide setup and run the commands below while you work through the feature together and review the Intent before approval.

## 1. Install

You need Git and a model account. Choose an installation method.

- ### Homebrew

```
brew trust kogenai/tap
brew install kogenai/tap/kogen
```

For macOS on Apple Silicon and Linux x86-64.

- ### Shell installer

```
curl -fsSL https://get.kogen.dev | sh
```

Downloads the latest release, verifies its checksum and installs into `~/.local`. If needed, add it to your shell’s path.

```
export PATH="$HOME/.local/bin:$PATH"
```

Release archives are available for macOS and Linux on arm64 and x86-64.

- ### Build from source

Follow the [source installation instructions](https://github.com/KogenAI/kogen#install) for the required Go and Node versions.

Check the installation with `kogen version`. Current downloads are development builds. The installer finds the latest release automatically.

## 2. Choose your provider

### ChatGPT

Sign in with your ChatGPT subscription. The command opens the browser to complete login.

```
kogen provider login chatgpt
```

Kogen uses Kogen Loop to run the models through its shaping, building and review stages.

### Claude subscription

Claude subscriptions run through Claude Code. Kogen manages a pinned copy with its own settings.

```
claude setup-token
kogen provider login claude-code
```

The first command creates a subscription token. Paste it into the second command’s private prompt.

Generating the token requires Claude Code. Kogen downloads its own tested copy when a stage first needs it.

### API keys and other subscriptions

Claude with an Anthropic API key runs through Kogen Loop.

```
kogen provider login anthropic
```

Kogen Loop also supports SuperGrok subscriptions, OpenCode Go workspace keys and OpenAI-compatible endpoints.

```
kogen provider login supergrok
kogen provider login opencode-go
kogen provider login openai-compatible
```

Choose the command for your provider. OpenAI-compatible login asks for the endpoint’s base URL and API key. Save credentials through the private prompts, then check local login status with `kogen provider list`.

## 3. Set up your repository

Start in a Git repository with at least one commit and a clean working tree.

```
cd your-repo
kogen init
```

Review the detected checks in `.kogen/project.yaml`, the model lineup in `.kogen/models.yaml` and the readiness lines. Follow any printed fix before continuing.

## 4. Shape and refine

Describe the feature in a file outside the repository, or have your agent write it with you.

```
kogen intent shape my-feature ../request.md
```

Answer any questions using the instructions Kogen prints. Once the Intent is ready, show its review card.

```
kogen intent approve my-feature
```

This displays the plan and its full SHA-256 hash. Exit status 5 is expected at this stage. To correct the ready package, use that hash and a correction file, then review the new card.

```
kogen intent refine my-feature <sha256> ../correction.md
```

## 5. Approve and build

After you review the Intent, approve its exact hash and start the Build.

```
kogen intent approve my-feature <sha256>
kogen intent build my-feature
```

Replace `<sha256>` with the full hash from the current card. Your agent waits for Kogen to finish. A completed Build reports `landed` and the resulting commit. If it stops, read the reason and follow the [recovery instructions](https://github.com/KogenAI/kogen/blob/main/docs/getting-started.md).

## For agents

Use Kogen’s shape and refine commands to prepare the feature, and its Build command to make the implementation. Ask the user for missing product decisions and approval of the exact Intent unless approval has been explicitly delegated. After a refinement, get the new approval hash. Hand private login to the user, and wait for the actual Build result before reporting completion.

To update a shell installation, rerun the installer. For Homebrew, run `brew update` and `brew upgrade kogenai/tap/kogen`.

---

Canonical page: https://kogen.dev/get-started