Capri Tutorial: Set Up a Cyberpunk AI Agent for Your Windows Desktop

What Is Capri?

Capri is a cyberpunk-styled AI agent for Windows. It provides a native desktop interface and an agent layer for AI assistants such as Claude Code, Codex, and Antigravity. Instead of working only from a terminal, you describe a goal in plain language and Capri routes the request to your selected assistant, coordinates tools, and reports the result.

Capri can work with files, project folders, code, shell commands, applications, and web-related tasks. It is designed for both developers and people who want a general-purpose assistant for their desktop.

The app is currently available for Windows 10 or newer. macOS and Linux support are planned but are not available yet.

Key Features

• Multiple AI engines: Use Claude Code, Codex, Antigravity, or another assistant through a custom adapter.
• Desktop-native interface: Work from a graphical application instead of a terminal-only workflow.
• File and project operations: Ask Capri to find, read, organize, edit, or analyze files and folders.
• Agent workflows: Capri can plan a task, use tools, check results, and explain what happened.
• Code assistance: Use your preferred engine to write, refactor, debug, and run code.
• Automation: Turn recurring chores into natural-language requests.
• Approval controls: Review sensitive actions and approve or deny them before they run.
• Cyberpunk interface: Use a dark, neon-inspired desktop experience.

Install Capri on Windows

1. Download a release

Open the latest Capri release and choose one of the available Windows packages:

• Capri-Setup.exe: Use the installer for a regular installation and a Start menu shortcut.
• Capri-Portable.zip: Use the portable build when you want to run Capri from a folder without installing it.

2. Launch the application

For the installer version, run Capri-Setup.exe, complete the setup wizard, and open Capri from the Start menu. For the portable version, extract Capri-Portable.zip into a folder and run the application from there.

Windows SmartScreen may display a warning because Capri is a newer application. If you downloaded the file from the repository's official Releases page, select More info and then Run anyway.

3. Connect an AI assistant

On the first launch, Capri asks which assistant you want to use. Select an available engine, then sign in to your account or provide the required API key. Capri supports Claude Code, Codex, and Antigravity out of the box. Other assistants can be connected through custom adapters.

Your choice of engine determines which AI system processes your requests, while Capri provides the desktop interface, routing, tools, and approval workflow.

Run Your First Task

Describe the goal in plain language

Start with a specific request that explains what you want Capri to accomplish. For example:

Clean up my Downloads folder and group everything by type.

Capri can scan the folder, propose a plan, and move files after you approve the action. For the first test, use a folder that does not contain irreplaceable data.

Try a coding task

Capri can use the connected engine to inspect a project, locate problems, modify code, and run checks. A suitable request might be:

Find the bug in this project, explain the cause, fix it, and run the existing checks.

When the task involves changing files or executing commands, review the proposed actions before approving them.

Work with documents

You can also ask Capri to process multiple files and produce a combined result:

Summarize every PDF in this folder into one document.

The assistant can read the files and write a consolidated summary, subject to the permissions and access available to Capri.

How Capri Processes a Request

1. Describe the goal: You provide a request in natural language.
2. Route the request: Capri sends it to the AI engine you selected.
3. Plan the work: The engine determines the steps and tools required.
4. Request approval: Capri gives you an opportunity to approve sensitive operations.
5. Execute and report: Capri uses the relevant tools and reports the outcome.

The tool layer can work with files and projects, shells and applications, and web-related tasks. The approval gate is intended to keep you involved when an action could change your system or data.

Choose and Switch Engines

Capri supports Claude Code, Codex, and Antigravity directly. The README also describes support for other assistants through custom adapters. Use the engine that best matches the task, then switch when another assistant is more suitable.

For example, you might use one engine for a coding workflow and another for a general desktop task. The exact sign-in or API-key process depends on the assistant provider you connect.

Configure Permissions and the Interface

The README provides the following example configuration:

engine: claude-code        # claude-code | codex | antigravity | custom

permissions:
  mode: ask                # ask before acting | auto | read-only
  allowed_folders:
    - ~/Documents
    - ~/Projects

interface:
  theme: cyberpunk

The engine setting selects the connected assistant. The permissions mode can be configured to ask before acting, run automatically, or use read-only access. The allowed_folders list limits the locations Capri can access, and the interface configuration selects the cyberpunk theme.

Use restrictive settings while learning the application. Start with mode: ask and only allow folders that are necessary for the task.

Advanced Usage and Automation Tips

Use precise task boundaries

Good requests identify the location, desired result, and limits. Instead of asking Capri to organize everything, specify a folder and explain how items should be grouped. This makes the proposed plan easier to review.

Automate repeated chores carefully

Capri is designed to turn repeated chores into a single sentence. Examples from the project include setting up a new web app and starting it, or asking for a recurring backup of your Documents folder. Review the resulting actions and verify that the destination and files are correct before enabling an ongoing workflow.

The roadmap separately lists a task scheduler as planned, so do not assume every scheduling feature is currently available in the released application.

Use custom adapters when needed

If your preferred assistant is not one of the built-in engines, the project describes custom adapters as the way to connect other assistants. Check the current release documentation and repository issues for implementation details before planning a custom integration.

Safety Recommendations

• Review actions before approval: Pay special attention to file deletion, movement, overwriting, and shell commands.
• Limit folder access: Give Capri access only to the directories required for the current task.
• Maintain backups: Back up important data before running large or automated operations.
• Protect credentials: Never share API keys, account tokens, or other authentication details.
• Check provider policies: Requests are processed by the AI assistant you connect, under that provider's terms and privacy policy.

Capri is designed to let you review actions, but no desktop automation tool is risk-free. Treat approval prompts as a security boundary rather than an inconvenience.

Troubleshooting and Support

If Windows blocks the application, confirm that you downloaded it from the project's official Releases page before using the SmartScreen override. If an assistant does not connect, verify the selected engine, sign-in status, and API key or account credentials.

For feature requests or problems, use the repository's issue tracker. The project roadmap includes macOS and Linux versions, a plugin system, a mobile companion, and a community cyberpunk theme gallery.

Conclusion

Capri combines a Windows desktop interface with the AI assistants you already use. After downloading the installer or portable build, connect an engine, describe a task, and review the proposed actions before allowing Capri to work with your files, projects, and applications. Start with limited permissions and simple requests, then expand into coding workflows and carefully reviewed automations.