Intro

Get started with FrownCode.

FrownCode is an open source AI coding agent by Kyssta. It’s available as a terminal-based interface, desktop app, or IDE extension.

FrownCode also includes custom workflow upgrades like built-in Caveman mode, /btw side-interrupt prompts, /close exit aliases, earlier automatic context compaction, and NVIDIA NIM support. See the feature overview.

Current Frown build

Same coding flow, sharper control surface.

Use Auto when you want FrownCode to pick from your configured providers, explain why it picked that model, and keep OpenRouter free limited to advisor-only routing.

TUI + desktop

Shared Auto rules

Set mode, provider preferences, model patterns, reasoning requirement, and advisor mode once. Both surfaces follow the same config.

Provider setup

NIM + tests

Connect NVIDIA NIM through its OpenAI-compatible endpoint, then use provider tests in the desktop app to verify metadata and available models.

Fast chats

Caveman + `/btw`

Caveman is on by default for compressed replies. /btw lets you inject side notes while work is moving.

Let’s get started.

Prerequisites

To use FrownCode in your terminal, you’ll need:

A modern terminal emulator like:
- WezTerm, cross-platform
- Alacritty, cross-platform
- Ghostty, Linux and macOS
- Kitty, Linux and macOS
API keys for the LLM providers you want to use.

Install

For now, FrownCode is distributed through npm.

npm install -g frowncode-ai

Then run:

frown

Configure

With FrownCode you can use any LLM provider by configuring your own API keys.

Run the /connect command in the TUI and select a provider (e.g., OpenAI, Anthropic, etc.).
```
/connect
```
Enter your API key when prompted.
```
┌ API key
│
│
└ enter
```

Alternatively, you can configure providers in your config file. Learn more.

Initialize

Now that you’ve configured a provider, you can navigate to a project that you want to work on.

cd /path/to/project

And run FrownCode.

frown

Next, initialize FrownCode for the project by running the following command.

/init

This will get FrownCode to analyze your project and create an AGENTS.md file in the project root.

This helps FrownCode understand the project structure and the coding patterns used.

Usage

You are now ready to use FrownCode to work on your project. Feel free to ask it anything!

If you want the Frown-specific upgrades first, read Frown Features.

If you are new to using an AI coding agent, here are some examples that might help.

Ask questions

You can ask FrownCode to explain the codebase to you.

How is authentication handled in @packages/functions/src/api/index.ts

This is helpful if there’s a part of the codebase that you didn’t work on.

Add features

You can ask FrownCode to add new features to your project. Though we first recommend asking it to create a plan.

Create a plan

FrownCode has a Plan mode that disables its ability to make changes and instead suggest how it’ll implement the feature.

Switch to it using the Tab key. You’ll see an indicator for this in the lower right corner.
```
<TAB>
```
Now let’s describe what we want it to do.
```
When a user deletes a note, we'd like to flag it as deleted in the database.
Then create a screen that shows all the recently deleted notes.
From this screen, the user can undelete a note or permanently delete it.
```
You want to give FrownCode enough details to understand what you want. It helps to talk to it like you are talking to a junior developer on your team.

Give FrownCode plenty of context and examples to help it understand what you want.
Iterate on the plan

Once it gives you a plan, you can give it feedback or add more details.
```
We'd like to design this new screen using a design I've used before.
[Image #1] Take a look at this image and use it as a reference.
```
Drag and drop images into the terminal to add them to the prompt.

FrownCode can scan any images you give it and add them to the prompt. You can do this by dragging and dropping an image into the terminal.
Build the feature

Once you feel comfortable with the plan, switch back to Build mode by hitting the Tab key again.
```
<TAB>
```
And asking it to make the changes.
```
Sounds good! Go ahead and make the changes.
```

Make changes

For more straightforward changes, you can ask FrownCode to directly build it without having to review the plan first.

We need to add authentication to the /settings route. Take a look at how this is
handled in the /notes route in @packages/functions/src/notes.ts and implement
the same logic in @packages/functions/src/settings.ts

You want to make sure you provide a good amount of detail so FrownCode makes the right changes.

Undo changes

Let’s say you ask FrownCode to make some changes.

Can you refactor the function in @packages/functions/src/api/index.ts?

But you realize that it is not what you wanted. You can undo the changes using the /undo command.

/undo

FrownCode will now revert the changes you made and show your original message again.

Can you refactor the function in @packages/functions/src/api/index.ts?

From here you can tweak the prompt and ask FrownCode to try again.

Or you can redo the changes using the /redo command.

/redo

The conversations that you have with FrownCode can be shared with your team.

/share

This will create a link to the current conversation and copy it to your clipboard.

Here’s an example conversation with FrownCode.

Customize

And that’s it! You are now a pro at using FrownCode.

To make it your own, we recommend picking a theme, customizing the keybinds, configuring code formatters, creating custom commands, or playing around with the FrownCode config.