UGT: Use the GitHub Thing

How it works

1. Start with the GitHub link. You can also add an error you ran into or something you want to do with the project.
2. Follow the setup for your computer. UGT looks for a ready setup or the project's own installer. If it needs a closer look, your AI app continues with the same link and details. A recipe is a setup someone has already checked; your agent can make one when the project has none.
3. Use what it made. Open the resulting file or app. File jobs check their output, and apps keep their saved data when you stop and reopen them. If a run fails, ask for help with that run without starting the conversation over.
4. Share it, if you like. Once it works, UGT can submit your recipe to the catalogue, so the next person gets it fast.

Get started

Paste your GitHub project into UGT. The link is enough. If you already tried to install it, you can include the error you saw.

UGT checks for a way to use that project on your computer. If it offers Open in UGT, open it, choose your file if it needs one, and run it. When a file is ready, UGT shows you its folder. An app opens at its own address.

If the project needs a closer look, continue in your desktop AI app. The website carries your link and notes into the project message. If UGT needs installing, it shows how to set it up. UGT has no subscription; your AI app's own usage limits and pricing still apply.

What you can do with it

GitHub is the world's biggest shelf of free software, and most of it never reaches the people it could help, because it ships as code, not as an app. UGT turns any of it into something you can just ask for.

_{A few featured examples. You never need a recipe from the catalogue: without one, your agent works the project out the first time. A recipe just makes it faster, because someone already did.}

Why not just ask your agent?

Your agent can read the code. It usually can't run it for you, and it starts from zero every time.

• Most of GitHub assumes Linux. On Windows and on a Mac your agent hits a wall. UGT brings its own private Linux engine, set up in one step, on Linux too: no Docker Desktop, no account, nothing to learn. On an Intel Mac it drives the engine you already have.
• Proven once, quick for everyone after. The first agent to get a project working can spend an hour building and fixing: memory limits, wrong-architecture binaries, missing system libraries, a resolver that cannot find the internet. The recipe it leaves behind turns the next person's run into a download.
• Proof, not "it started". A container starting is not your job done. Every recipe carries a check that fails unless the output is real: subtitles that fit the recording, a video of the length you asked for, a mesh you can actually print.
• Your machine, your files. Projects run in a sandbox with only the files and access their recipe declares. The catalogue reviews that access before admitting a recipe; UGT asks before a locally made recipe reaches beyond its ordinary sandbox. Cloud compute requires your agreement and a stated cost.

The catalogue

Recipes are a shortcut, never a requirement. Each one is a project someone already got doing a job, shared so nobody has to work it out again. A recipe is a folder anyone can read, in recipes/: a compose.yaml that holds everything that runs, and a recipe.json that says what it does. One project can have many recipes, one per job.

Browse them at usegithubthing.com/recipes, or read their source in recipes/. Every one was verified on clean machines before it was admitted, and a new recipe works for everyone the moment it lands, with no update to UGT.

_{Verified means every service ran as written on clean amd64 and arm64 machines and passed both checks, and both checks rejected deliberately broken outputs. A featured recipe's image is the one that was verified; any other builds on your machine from the same pinned commit and bases.}

recipes/openai/whisper/subtitles/  compose.yaml    everything that runs: build, limits, mounts, network, and the four services  recipe.json     what it is: project, commit, task, settings, the access it needs, licence  Dockerfile      fetches the pinned source itself, so the build needs no clone  check/          the check scripts

Share your recipe

Got a project doing something useful? Share it, so the next person gets it fast instead of working it out again.

Tell your AI "Use the GitHub Thing: share this recipe", or run ugt recipe submit. UGT checks it runs again from scratch, makes sure nothing personal goes with it (your files, paths and keys), and opens a pull request as you. It is then verified on clean machines with no secrets available, and admitted once it passes; a maintainer reviews any recipe that reaches beyond its sandbox first.

_{Coming with the UGT app. Until then, from the source:}

go install github.com/auscaster/ugt/cmd/ugt@latestugt recipe new <owner>/<repo> <task>     # start one, or adopt the project's own Compose fileugt recipe verify <folder>               # until it passesugt login                                # once: approve a code in your browserugt recipe submit <folder>               # opens the pull request as you

ugt recipe submit --dry-run shows exactly what would be sent first. CONTRIBUTING.md and the catalogue rules have the details.

Maintain a project? A "Run with UGT" badge is on the way: put it in your README, and one click opens your project in UGT.

House rules

• Your files stay yours. Inputs are copied in. Your home folder, keys and the container engine are never handed to a project unless its recipe says why and a maintainer reviewed it, or you agree.
• Run anything, hide nothing. A recipe can need the internet, a folder, a device or more. It declares each one, and UGT refuses anything it did not declare. A maintainer reviews it before the catalogue admits it; a recipe from anywhere else asks you before it reaches your computer.
• Proof or it didn't happen. No check, no success.
• You decide. Installs, admin prompts, big downloads, accounts, keys and cloud compute are always your call, asked plainly before they happen.
• Secrets never pass through your agent. UGT asks you for them itself, once, and they live in your system keychain.
• Credit travels with the code. Every recipe records its project's licence, and files adapted from upstream keep theirs.
• Your files never leave your computer. UGT asks its catalogue which recipes a project has, downloads what a recipe needs, and sends run reports only if you agree: which recipe ran and how it went, never your files, paths or output. The privacy policy has the rest.

License

Apache-2.0. Each packaged project keeps its own licence. The UGT name and logo are not licensed; see NOTICE. Security issues go to SECURITY.md.