# AI use cases for Ufo Core (ufo-ai/ufo-core)

Repo: [ufo-ai/ufo-core](https://github.com/ufo-ai/ufo-core) | Use cases: 5 | Page: https://dedupedai.com/use-cases/ufo-ai-ufo-core/

UFO is an open source Python runtime that lets a team run AI agents in chat, with the agents reading files and running commands, either on self-hosted infrastructure or through UFO's hosted service.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Run a shared team agent server on one machine: https://dedupedai.com/use-cases/ufo-ai-ufo-core/self-host-team-agent-on-one-machine/
- Hand a task to an agent in a hosted sandbox: https://dedupedai.com/use-cases/ufo-ai-ufo-core/hand-coding-task-to-hosted-sandbox/
- Move a team UFO server onto Postgres: https://dedupedai.com/use-cases/ufo-ai-ufo-core/run-team-server-on-postgres/
- Serve an agent-built site on a local subdomain: https://dedupedai.com/use-cases/ufo-ai-ufo-core/publish-agent-built-site-on-subdomain/
- Read agent turns and memory in a browser debugger: https://dedupedai.com/use-cases/ufo-ai-ufo-core/inspect-agent-turns-in-debugger/

## How to run a shared team agent server on one machine with Ufo Core

Repo: [ufo-ai/ufo-core](https://github.com/ufo-ai/ufo-core) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Install UFO on SQLite and local files so a small team can chat with agents on its own hardware.

**Who it is for:** A developer or IT admin at a small team who wants agents for the team without sending work through a hosted service.

**The problem:** Team members want agents that can read files and run commands, but the team wants the runtime and its data on its own machine.

**The outcome:** A running UFO server on localhost where the admin is the workspace owner and a terminal client can send work to an agent.

### Steps

1. Run `make install`
2. Run `cp .env.template .env` and set the three model API keys in `.env`
3. Run `make build`
4. Run `make init EMAIL=email@work.com` with your work email
5. Run `make serve` and keep it running, then open a second terminal

### Prompt to paste into your agent

```text
In the ufo-core repo, follow the Quick start to run `make install`, `make build`, `make init EMAIL=<work email>`, and `make serve`. Expected output: the server listens on http://localhost:8710 and `~/.ufoctl/token` exists. Verify that `curl http://localhost:8710` returns a response before you report success.
```

### Caveat

The default local sandbox can read the whole host and the kernel does not enforce its egress, so use docker or e2b for untrusted input.

Risk, credentials: The three model API keys and the CLI token in ~/.ufoctl/token grant access to your model accounts and workspace, so keep .env and the token private.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/ufo-ai-ufo-core/self-host-team-agent-on-one-machine/

## How to hand a task to an agent in a hosted sandbox with Ufo Core

Repo: [ufo-ai/ufo-core](https://github.com/ufo-ai/ufo-core) | Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Give an agent a task from the terminal that keeps running in a sandbox after the client exits.

**Who it is for:** A developer who wants an agent to do a longer task, such as a repo change, without tying up a laptop.

**The problem:** Local agent runs stop when the terminal closes, and running them on a laptop exposes local files to the agent.

**The outcome:** An agent working in the workspace sandbox, with the turn continuing after ufo exits and the result readable later with --resume.

### Steps

1. Run `curl -fsSL https://ufo.ai/ufo | sh`
2. Run `ufo` and sign in
3. Run `ufo --remote` followed by your task in quotes (inferred, check the README)
4. Run `ufo --remote --resume ID` with the turn ID to read the rest of the output (inferred, check the README)

### Prompt to paste into your agent

```text
Use the ufo client from the ufo-core repo to send the task <task description> with `ufo --remote`. Expected output: a turn ID and a sandbox result under /workspace. Verify the turn ID by running the resume command before you report the result.
```

### Caveat

The hosted service needs a workspace created at ufo.ai, and the README does not say what the --wait flag is measured against beyond its seconds value.

Risk, remote script: The install step pipes a remote script from ufo.ai into sh, so check the script or the source before you run it on a machine that holds other credentials.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/ufo-ai-ufo-core/hand-coding-task-to-hosted-sandbox/

## How to move a team UFO server onto Postgres with Ufo Core

Repo: [ufo-ai/ufo-core](https://github.com/ufo-ai/ufo-core) | Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Point the server at a local Postgres database before creating the workspace.

**Who it is for:** An ops engineer setting up a UFO server for several users who need a database that is not SQLite.

**The problem:** The default SQLite setup is meant for one process on one machine, and a larger deploy needs a shared database.

**The outcome:** A UFO server reading and writing a Postgres database named ufo, with the workspace created in that database.

### Steps

1. Run `make db`
2. Write `ufo.toml` with the Postgres URL using the command in the Postgres section of the README
3. Run `make init EMAIL=email@work.com`
4. Run `make serve`

### Prompt to paste into your agent

```text
In the ufo-core repo, run `make db`, write ufo.toml as the README's Postgres section describes, then run `make init EMAIL=<work email>` and `make serve`. Expected output: the server starts on http://localhost:8710 against postgresql+asyncpg on 127.0.0.1:5541. Verify that ufo.toml contains the postgresql+asyncpg URL before you report success.
```

### Caveat

The README gives the Postgres connection string only for the local make db setup, and scale-out to S3 and Redis is described in one line without steps.

Risk, credentials: The README example uses the default Postgres user and password ufo:ufo, so change them before the database holds real team data.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/ufo-ai-ufo-core/run-team-server-on-postgres/

## How to serve an agent-built site on a local subdomain with Ufo Core

Repo: [ufo-ai/ufo-core](https://github.com/ufo-ai/ufo-core) | Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Run the ingress so sites that agents build are reachable on ufo.localhost subdomains.

**Who it is for:** A developer who wants agents to build small web pages or internal tools and preview them in a browser.

**The problem:** An agent can build a site in the sandbox, but there is no address where a person can open it.

**The outcome:** A site served on a subdomain of http://ufo.localhost:8100 that the developer can open in a browser.

### Steps

1. Run `make install` and `make build` if the server is not set up yet
2. Run `uv run ufoctl ingress` in a second terminal
3. Ask the agent to build the site in the workspace and note its subdomain
4. Open the subdomain under http://ufo.localhost:8100 in a browser

### Prompt to paste into your agent

```text
In the ufo-core repo, run `uv run ufoctl ingress` and ask the agent to build <site description> in the workspace. Expected output: the site loads at a subdomain of http://ufo.localhost:8100. Verify the page loads in a browser before you report success.
```

### Caveat

Private sites need a sign-in gateway set in [serve] sign_in_path, and the README does not give steps for building that gateway.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/ufo-ai-ufo-core/publish-agent-built-site-on-subdomain/

## How to read agent turns and memory in a browser debugger with Ufo Core

Repo: [ufo-ai/ufo-core](https://github.com/ufo-ai/ufo-core) | Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Open turns, steps, transcripts, and memory in a browser to see what an agent did.

**Who it is for:** A developer or team lead who needs to check why an agent took an action before trusting its work.

**The problem:** An agent's run is hard to audit from the chat alone, especially when several turns or steps are involved.

**The outcome:** A browser view of a workspace's turns, steps, transcripts, and memory for review.

### Steps

1. Run `make debugger`
2. Run `make serve` after the debugger build finishes
3. Run `uv run ufoctl debugger` in a second terminal

### Prompt to paste into your agent

```text
In the ufo-core repo, run `make debugger` before `make serve`, then run `uv run ufoctl debugger`. Expected output: a browser view of turns, steps, transcripts, and memory. Verify that at least one turn from the workspace appears before you report success.
```

### Caveat

The debugger needs pnpm, and the README says make debugger must run before make serve.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/ufo-ai-ufo-core/inspect-agent-turns-in-debugger/