# AI use cases for Gufo (gufo-org/gufo)

Repo: [gufo-org/gufo](https://github.com/gufo-org/gufo) | Use cases: 4 | Page: https://dedupedai.com/use-cases/gufo-org-gufo/

Gufo is an open source local inference engine in C++ built for AMD Strix Halo systems, serving text, audio, image, and video models through an OpenAI-compatible API.

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

- Run Qwen3.8 27B as a private local API on Strix Halo: https://dedupedai.com/use-cases/gufo-org-gufo/serve-qwen-27b-local-api/
- Point Codex at a local Qwen model through Gufo: https://dedupedai.com/use-cases/gufo-org-gufo/connect-codex-to-local-qwen/
- Build Gufo from source with Nix and run diagnostics: https://dedupedai.com/use-cases/gufo-org-gufo/build-gufo-from-source-with-nix/
- Compare Gufo speed with a llama.cpp baseline: https://dedupedai.com/use-cases/gufo-org-gufo/benchmark-gufo-against-llama-cpp/

## How to run Qwen3.8 27B as a private local API on Strix Halo with Gufo

Repo: [gufo-org/gufo](https://github.com/gufo-org/gufo) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Download the model and start a local OpenAI-compatible chat endpoint on port 8080 in one container.

**Who it is for:** A developer with a Strix Halo workstation who wants a private, self-hosted LLM endpoint for apps or chat tools.

**The problem:** Cloud model APIs send prompts off the machine, and running a large model locally needs GPU setup that is easy to get wrong.

**The outcome:** A running local server that answers chat requests at http://localhost:8080/v1 with the Qwen3.8 27B model.

### Steps

1. Run `hf download unsloth/Qwen3.8-27B-GGUF Qwen3.8-27B-UD-Q8_K_XL.gguf --revision 4ca720788d1e01f1bff70c033e0d0028fd02e502 --repo-type model --local-dir models/Qwen3.8-27B-GGUF` to get the main model file. (inferred, check the README)
2. Run `hf download z-lab/Qwen3.8-27B-DFlash2-GGUF Qwen3.8-27B-DFlash2-Q4_K_M.gguf --revision 2d9571f8ce46e151f61c6499c99dee6079e1d610 --repo-type model --local-dir models/Qwen3.8-27B-DFlash2-GGUF` to get the DFlash2 draft model. (inferred, check the README)
3. Run `podman pull ghcr.io/gufo-org/toolboxes/gufo-runtime:latest` to fetch the Gufo runtime image.
4. Run the `podman run` command from the README Quickstart with `--device /dev/kfd`, `--device /dev/dri`, `-p 8080:8080`, and `gufo serve --host 0.0.0.0 --port 8080 llm` using the two model paths and `--speculative dflash2`.
5. Run `curl http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{"model": "Qwen3.8-27B-UD-Q8_K_XL", "messages": [{"role": "user", "content": "Say something"}]}'` from a second terminal to test it. (inferred, check the README)

### Prompt to paste into your agent

```text
Using the gufo repo, help me serve the Qwen3.8 27B model on my Strix Halo machine at <host path to models folder>. Follow the Quickstart in the README, then send one chat request to http://localhost:8080/v1/chat/completions. Report the HTTP status and the reply text, and confirm the container logs show no ROCm device error.
```

### Caveat

Gufo targets AMD Strix Halo (gfx1151) on Linux x86-64; the README does not claim support for other GPUs, and rootless Podman may need group and SELinux fixes described in the README before the GPU is visible.

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/gufo-org-gufo/serve-qwen-27b-local-api/

## How to point Codex at a local Qwen model through Gufo with Gufo

Repo: [gufo-org/gufo](https://github.com/gufo-org/gufo) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Set the Codex or OpenAI SDK base URL to your local Gufo server so coding sessions stay on your machine.

**Who it is for:** A developer who uses Codex for coding work and wants to keep code and prompts on local hardware.

**The problem:** Coding agents normally call a hosted model API, which sends source code outside the machine.

**The outcome:** Codex or an OpenAI SDK script sends requests to the local Qwen model, with text, function tools, and streaming working through Gufo.

### Steps

1. Start the Gufo server as described in the Quickstart so it listens on port 8080.
2. Set the API base URL for Codex or your OpenAI SDK client to `http://localhost:8080/v1`.
3. Use the model name `Qwen3.8-27B-UD-Q8_K_XL` in the client configuration.
4. Send a short test prompt from the client and confirm a streamed reply arrives.
5. Read the README harness notes on Codex developer messages and prefill behavior before long sessions.

### Prompt to paste into your agent

```text
In the gufo repo, configure Codex to use the OpenAI-compatible base URL http://localhost:8080/v1 with model <model name>. Send one prompt asking for a one-line Python hello world and report the reply. Verify that the response is streamed and that Gufo logs show a completed request.
```

### Caveat

The README says Qwen with Claude Code is not supported, so this path only covers Codex and OpenAI-style clients.

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/gufo-org-gufo/connect-codex-to-local-qwen/

## How to build Gufo from source with Nix and run diagnostics with Gufo

Repo: [gufo-org/gufo](https://github.com/gufo-org/gufo) | Difficulty: Advanced | Time: 2 hours | Basis: From the README

Compile the production package with Nix, check the Strix Halo setup, and start a local model.

**Who it is for:** A Linux engineer on Strix Halo who wants a reproducible build or needs to debug GPU access before serving models.

**The problem:** ROCm and GPU setup on Strix Halo is fragile, and a manual build can drift from the tested toolchain.

**The outcome:** A built Gufo binary that reports the device status and serves a local GGUF model.

### Steps

1. Clone the Gufo repo and run `nix build` in its root to build the production package.
2. Run `./result/bin/gufo diagnose` to check the GPU and runtime setup.
3. Run `./result/bin/gufo serve llm --model /path/to/model.gguf` with your own GGUF model file.
4. If the build needs the development tools, run `nix develop` as the README describes for profiling and model download tools. (inferred, check the README)

### Prompt to paste into your agent

```text
Clone the gufo repo, run nix build, then run ./result/bin/gufo diagnose and report its full output. Start ./result/bin/gufo serve llm --model <path to GGUF file> and confirm the server reports it is listening.
```

### Caveat

The README states the Nix package includes a ROCr 7.2.3 patch for Strix Halo, so a build on other GPU or ROCm setups is outside the documented target.

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/gufo-org-gufo/build-gufo-from-source-with-nix/

## How to compare Gufo speed with a llama.cpp baseline with Gufo

Repo: [gufo-org/gufo](https://github.com/gufo-org/gufo) | Difficulty: Advanced | Time: 3 hours | Basis: From the README

Run Gufo's benchmark guide against optional llama.cpp reference builds on your own Strix Halo box.

**Who it is for:** A performance-minded developer who wants to check published Gufo throughput numbers on their own hardware.

**The problem:** Published tokens-per-second figures are hard to trust without running the same workload on the same machine.

**The outcome:** Your own measured prompt and generation rates next to a llama.cpp reference for the same model class.

### Steps

1. Read docs/BENCHMARKS.md in the Gufo repo for the complete benchmark settings.
2. Run `nix develop` to get profiling and evaluation tools.
3. Run `nix shell .#llama-cpp-reference` to load the optional llama.cpp baseline. (inferred, check the README)
4. Run the benchmark workload described in each model guide, such as the Qwen3.8 27B BENCHMARKS.md file.
5. Record pp and tg numbers and compare them with the README table.

### Prompt to paste into your agent

```text
In the gufo repo, follow docs/BENCHMARKS.md to run the Qwen3.8 27B benchmark on <model path> against the llama.cpp reference. Report prompt processing and token generation rates in tok/s and compare them with the README figures. Verify the same model file and settings were used for both runs.
```

### Caveat

The README says peak numbers use specific short-prompt and repetitive-output workloads, so your results will differ unless you match the documented settings exactly.

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/gufo-org-gufo/benchmark-gufo-against-llama-cpp/