tavernai.net

TavernAI 2 supports two connection paths for generation: load GGUF language and vision models directly inside the app, or point the same chat at one of the built-in or custom API integrations. The local route runs on your own hardware with CPU, CUDA, or Vulkan; the API route sends generation to an external provider. You can switch between them inside the same chat, so the choice is per-chat rather than permanent.

Local models: GGUF loaded inside TavernAI

TavernAI 2 loads GGUF language and vision models directly, without a separate inference server. The website lists CPU, CUDA, and Vulkan as the available runtimes.

• CPU works on any machine but is the slowest option for larger models.
• CUDA uses NVIDIA GPUs and is the usual choice when you have one.
• Vulkan covers a wider range of GPUs, including AMD and Intel hardware.

The practical constraint is memory. A GGUF model has to fit in your available RAM or VRAM alongside the app itself, so the model size you can run locally is set by your hardware, not by TavernAI. Vision models follow the same loading path, which means image understanding runs locally too.

Because nothing leaves your machine on this path, local generation is the option to pick when privacy or offline use matters more than speed.

API providers: built-in and custom integrations

The same chat can switch to an API integration instead. The site states TavernAI 2 ships with more than a dozen built-in and custom API integrations, and that you bring your own provider — there is no bundled account or included credits.

For any provider you connect, expect to supply the credentials and identifiers that provider requires. In practice that means:

1. API key — issued by the provider's dashboard.
2. Endpoint or base URL — the address requests are sent to, which matters for self-hosted or proxy setups.
3. Model name — the specific model identifier you want that provider to run.

The site does not publish a provider list, per-provider setup screens, or pricing, so treat the exact fields as provider-dependent and check the provider's own documentation for the values. TavernAI 2 does not require an account to use the app itself, but your API provider almost certainly will.

Local vs. API: what actually differs

Choose local when you have the hardware and want prompts, attached files, and chat history to stay on your machine. Choose an API provider when your hardware can't run the model size you want, or when you'd rather not manage model files at all.

What stays the same either way

The connection choice doesn't change how the chat is built. Prompt Manager folders, activation rules, roles, placement, presets, token counters, and structural nodes assemble the prompt the same way regardless of backend, and you can open the final assembled prompt before generation to see every role, source, token, attachment, and the raw request. Files attached to prompt items — images, PDFs, documents, audio, video, text — join the same context system as characters, scenes, and chat history.

That means switching from local to API mid-project doesn't require rebuilding your prompt structure; it changes who generates the reply, not what you send.

Common snags

• Model won't load locally. Almost always a size problem — the GGUF exceeds available RAM or VRAM. Drop to a smaller quantization or a smaller model.
• API requests fail. Check the three values above in order: key, endpoint, model name. A valid key with the wrong model identifier fails the same way as a bad key.
• Slow local generation. Confirm which runtime is actually active; falling back to CPU when a GPU is present is a frequent cause.
• Unexpected cost. The site lists no pricing, so any spend comes from your provider's terms, not from TavernAI 2.

For installation itself — Windows 10/11 download or the Linux VPS terminal script — see the separate install walkthrough.

TavernAI 2 installs two ways: a desktop download for Windows 10/11 (including a portable version, with no account required), or a one-line terminal script on a Linux VPS that extracts the app to ~/TavernAI and adds an update script. Either path gets you the app itself — you still need to connect an AI provider or load a local model before you can chat.

Before you install

Check these first, since both install paths assume them:

• Windows: Windows 10 or 11. The site lists a desktop download and a portable app; the portable build is the one to pick if you don't want a fixed install location.
• Linux VPS: a server you can reach over SSH with curl available. The script writes to your home directory, so no special system-wide permissions are implied.
• Either way: enough disk space for the app plus any local models you plan to load (GGUF language and vision models can be large), and a network connection for the initial download and for any API provider you connect later.

No account is required to install or run the app.

Installing on Windows 10/11

1. Go to tavernai.net and take the Windows download for Windows 10/11. If you want a self-contained copy, choose the portable version instead of the standard installer.
2. Run the downloaded file and let it place the app on your machine (or unpack it, for the portable build).
3. Launch TavernAI 2. You land in the chat workspace with cards, the Prompt Manager, and the chat interface — but no model is connected yet.
4. Move on to "Connecting a model" below before expecting a reply.

Expected result: the app opens and you can create or import a character card, but sending a message won't produce output until a provider or local model is set up.

Installing on a Linux VPS

The site provides a single install command for Linux servers:

curl -fsSL https://tavernai.net/install.sh | bash

What this does, per the site's description:

• Downloads the latest stable build.
• Extracts it to ~/TavernAI.
• Adds an update script so you can pull newer builds later without repeating the whole process.

Expected result: a ~/TavernAI directory containing the app, plus an update script you can run when a new stable build is released.

Verify it worked: confirm the directory exists and contains the app files:

ls ~/TavernAI

If the directory is missing or empty, the download likely failed — check that the VPS has outbound network access and that curl is installed.

Connecting a model so you can actually chat

Installing the app is only half the setup. TavernAI 2 supports two routes, and you pick one (or switch between them per chat):

The site notes more than a dozen built-in and custom API integrations, and that you can switch the same chat between local models and a provider. After connecting either one, send a test message in a chat to confirm replies generate.

Common snags

• App opens but nothing generates. Almost always a missing provider or model — the install doesn't bundle one.
• Local model won't load. Check whether your hardware matches the backend you selected (CPU vs. CUDA vs. Vulkan); a CUDA build won't help on a machine without a compatible GPU.
• VPS install fails silently. Re-run the curl command and watch the output; a blocked outbound connection or missing curl is the usual cause.
• You want to update later. Use the update script the installer added rather than re-running the install from scratch.

Once a model is connected, the rest of the app — branching chats, dynamic cards, the Prompt Manager, per-character prompt trees, and the assembled-prompt viewer — is available without further installation steps.

TavernAI 2 is a local AI roleplay chat app, but its own site frames it as more than that: a chat workspace where you define how a world works, what each character knows, and exactly what reaches the model. Beyond one-on-one roleplay, you can build interactive AI games, run multi-character worlds with separate histories, let the AI or the user play any character, and restyle the whole interface. These capabilities come from the same underlying system — cards, the Prompt Manager, and the chat workspace — so what you build depends on how you configure those parts, not on separate tools.

Turn TavernAI into an AI game engine

The site describes building interactive AI games with their own interface, persistent state, branching logic, scripts, prompts, and assets. In practice, that means a game is assembled from the same pieces as a chat:

• Interface — the game presents its own UI rather than a plain chat window.
• Persistent state — information survives across turns instead of resetting each message.
• Branching logic and scripts — the flow can split and respond to conditions.
• Prompts and assets — generation is steered by prompt structure, and files can be attached.

This is a build-it-yourself path, not a library of ready-made games. If you want a structured interactive experience rather than an open-ended conversation, this is the feature to explore.

Run one world with many lives

TavernAI 2 supports giving every character their own history and knowledge. When characters meet, their timelines come together, the shared event is preserved in each life, and then their stories separate and continue again.

A concrete example: two characters each accumulate separate backstories. You bring them into the same scene, and that meeting is recorded for both. Afterward, each continues on its own thread with the shared event intact. This is useful for persistent-world storytelling where characters shouldn't share a single merged memory by default.

Decide who plays whom

Any character can be played by the AI or by the user. You can add any number of participants and decide independently:

• who generates replies,
• who represents the user,
• whose information enters the model context.

That last point matters: a participant can be present in the scene without their details being sent to the model. This gives you control over what the AI actually knows at any moment.

Build the prompt as a system

The Prompt Manager is where much of this control lives. According to the site, you control the entire generation pipeline with folders, activation rules, roles, placement, presets, token counters, structural nodes, and visual merge groups. Two related capabilities stand out:

• Drop files straight into the prompt — attach images, PDFs, documents, audio, video, or text directly to any prompt item, so files become part of the same context system as characters, scenes, and chat history.
• See exactly what the model sees — open the final assembled prompt before generation, including every role, source, token, attachment, transformation, and the raw request itself.

Each character is also its own prompt system: an ordered prompt tree with any prompts, folders, rules, scripts, files, and structure it needs, with avatar, identity, and behavior traveling together in one card.

Make the interface yours

You can rebuild TavernAI around your own colors, surfaces, typography, opacity, and chat style, then save the result as a reusable theme. If you're building a game or a themed world, this lets the presentation match the content instead of staying in a default chat look.

How to get there

The site lists a Windows 10/11 download, a portable app, and no account requirement, with "bring your own provider" for model access. For a Linux VPS, the documented install is a terminal command:

curl -fsSL https://tavernai.net/install.sh | bash

The site states this downloads the latest stable build, extracts it to ~/TavernAI, and adds an update script. You can also run models locally by loading GGUF language and vision models with CPU, CUDA, or Vulkan, or switch the same chat to built-in and custom API integrations.

What to check before committing

• Model source — decide up front whether you'll run GGUF models locally or connect a provider; the site says both are supported in the same chat.
• Prompt complexity — the game-engine and multi-character features lean on the Prompt Manager, so expect to spend time there rather than in a settings toggle.
• Platform — Windows 10/11 and Linux VPS installs are documented; the portable app and no-account requirement lower the setup barrier.

If your goal is a single roleplay chat, the core app is enough. If you want branching games, shared-world timelines, or a custom-themed interface, those are the areas to build out first.

The Prompt Manager in TavernAI 2 is the layer that decides what actually reaches the AI model. Instead of a single text box where you paste a character description and hope for the best, it treats the prompt as a structured system: folders, activation rules, roles, placement, presets, token counters, structural nodes, and visual merge groups. Each character can carry its own prompt tree, and you can open the fully assembled prompt before generation to see every role, source, token, attachment, transformation, and the raw request itself. If you want to understand why a character behaves a certain way — or fix it when it doesn't — this is the mechanism to learn.

The core idea: a prompt is a tree, not a string

In a simple chat app, the prompt is usually one block of text: system message, then history, then your input. TavernAI 2 replaces that with an ordered tree. Each node in the tree is a prompt item, and each item has properties that determine whether it fires and where its output lands in the final request.

The building blocks the site describes:

• Folders — group related prompt items so you can enable, disable, or reorder them as a unit.
• Activation rules — conditions that decide when a prompt item is included.
• Roles — who a prompt item speaks as (system, user, assistant, or character-specific).
• Placement — where in the assembled prompt the item's content appears.
• Presets — saved configurations you can switch between.
• Token counters — visibility into how much of the context window each item consumes.
• Structural nodes — items that shape the prompt's structure rather than adding prose.
• Visual merge groups — combine items so they render as a single block in the final prompt.

Because these are properties of items rather than hardcoded positions, the same character can produce very different prompts depending on which folders are active and which rules pass.

How a character becomes its own prompt system

The site states that every character is built from an ordered prompt tree with any prompts, folders, rules, scripts, files, and structure it needs — and that the avatar, identity, and complete behavior travel together in one card. Practically, this means:

1. You define the character's prompt tree once, inside the card.
2. The card carries that tree wherever it goes — no separate global prompt you have to remember to load.
3. Two characters in the same chat can have completely different prompt structures, because each one brings its own.

This is what makes "one world, many lives" work: each character has its own history and knowledge, and when their timelines meet, the shared event is preserved in each life before the stories separate again.

Attaching files directly to prompt items

Any prompt item can take attachments: images, PDFs, documents, audio, video, or text. The site's framing is that files become part of the same context system as characters, scenes, and chat history — they aren't a separate upload bucket. So if a scene depends on a reference image or a PDF of lore, you attach it to the prompt item that needs it, and it enters the assembled prompt alongside everything else.

Verifying what the model actually sees

Before generation, you can open the final assembled prompt. The site lists what's exposed: every role, source, token, attachment, transformation, and the raw request itself. Use this to:

• Confirm an activation rule fired when you expected it to.
• Check that a folder you disabled is genuinely absent.
• See how many tokens an attachment or a long history is consuming.
• Catch placement mistakes — content landing in the wrong role or position.

If a character is ignoring an instruction, this view is usually where the answer is: the instruction either didn't activate, got merged into a block that diluted it, or was pushed out by token pressure.

A concrete example

Say you're running a mystery scenario with two characters who share a past event.

• Character A's card has a folder for "shared history" with an activation rule tied to the presence of Character B.
• Character B's card has its own folder for the same event, written from its perspective.
• You attach a reference image of the location to a scene prompt item.
• A structural node places the scene description before the character prompts.
• A merge group combines both characters' shared-history items so they appear as one consistent block.

Before sending, you open the assembled prompt: both folders fired, the image is attached, the scene sits in the right position, and the token counter shows you have room left. If Character A suddenly acts as if it never met B, you check the activation rule first — that's the most common failure point.

Where to go next

The Prompt Manager is one part of a larger workspace that also covers provider setup, Macros, and PM Scripts. If you haven't installed the app yet, the Windows build targets Windows 10 and 11, and there's a portable option; on a Linux VPS the install script downloads the latest stable build, extracts it to ~/TavernAI, and adds an update script. No account is required, and you bring your own provider — either local GGUF models (CPU, CUDA, or Vulkan) or one of the built-in and custom API integrations.

TavernAI 2 is a local AI roleplay chat desktop app, and tavernai.net is its official website. The site provides the download for Windows 10 and 11, a terminal install path for Linux VPS/server deployments, and an overview of the app's chat, character, and prompt-building features. It is aimed at people who want to run roleplay or character-driven chats with their own models or API providers rather than through a hosted account-based service.

What the app is

TavernAI 2 is described as a local AI roleplay chat app built around a chat workspace with character cards, a Prompt Manager, and branching chats. The site presents it as a desktop application, with a portable app option, and states that no account is required.

Two ways to supply the AI are listed:

• Local models — load GGUF language and vision models directly inside TavernAI using CPU, CUDA, or Vulkan.
• External providers — switch the same chat to more than a dozen built-in and custom API integrations.

Core features

Chat and characters

• Branching chats — conversations can split into branches rather than following a single linear thread.
• Dynamic cards / dynamic participants — add any number of participants and decide independently who generates replies, who represents the user, and whose information enters the model context.
• Per-character prompt systems — each character is built from an ordered prompt tree with its own prompts, folders, rules, scripts, files, and structure. The avatar, identity, and behavior travel together in one card.
• Shared timelines — characters can have their own history and knowledge; when their timelines meet, the shared event is preserved in each life and the stories can then separate again.

Prompt Manager

The Prompt Manager is presented as a way to control the whole generation pipeline:

• Folders, activation rules, roles, placement, presets, token counters, structural nodes, and visual merge groups.
• Attach images, PDFs, documents, audio, video, or text directly to any prompt item, so files become part of the same context system as characters, scenes, and chat history.
• Inspect the final assembled prompt before generation — every role, source, token, attachment, transformation, and the raw request itself.

AI games and interface

• AI game engine — build interactive AI games with their own interface, persistent state, branching logic, scripts, prompts, and assets.
• Theming — rebuild the interface with your own colors, surfaces, typography, opacity, and chat style, then save it as a reusable theme.
• Image generation — the site states any chat model can generate images.

Download and installation

The documented server install command is:

curl -fsSL https://tavernai.net/install.sh | bash

According to the site, on a Linux VPS this script downloads the latest stable build, extracts it to ~/TavernAI, and adds an update script. The site also links to further server deployment documentation.

Who it fits

TavernAI 2 is a reasonable fit if you want a local, account-free roleplay chat app and are willing to bring your own model or API provider — either by running GGUF models on your own hardware or connecting an external service. It is a poorer fit if you want a fully hosted chat with no setup, since the site describes a desktop app and a self-managed server install rather than a managed service.

The site does not list pricing or payment details, so nothing here should be read as confirming the app is free or paid. Check the official site for current download and deployment specifics before installing.