UNCUT
The lossless, headless coding-agent harness: one 7 MB static binary, four tools, plain stdin/stdout, and no silent context cuts.
- Source repo
- Balanov/uncut
- Stars
- ★ 600
- Last updated
- 2d ago
- License
- MIT
- Primary language
- Go
- FA score
- 56/100 · Major gaps
At a glance
- Works with
- Universal · cross-platformOpenAI API
- You'll need
- Typical use
- Add a repair step to CI: run uncut "Run the tests and fix the failure" so the model reads code, edits files, and runs tests, treating exit codes 3 and 4 as pipeline failures.
- Main limitation
- Not a sandbox: run_command executes with your OS user's permissions and workspace path checks do not constrain shell commands, so untrusted tasks need a disposable container.
- Source review
- 56/100 · Major gaps 2 safety controls not found
What does this agent do, and when should you use it?
UNCUT is a deliberately minimal coding-agent harness written in Go and shipped as a single roughly 7 MB static binary with no runtime or third-party Go dependencies. It contains one agent loop, one OpenAI-compatible Chat Completions provider adapter, and exactly four tools: read_file, write_file, replace, and run_command. It intentionally omits a TUI, telemetry, plugins, background agents, automatic retries, and context compaction, so the entire conversation is resent on every model call and valid UTF-8 prompts, file contents, and command output are never truncated by the harness. It targets shell pipelines, CI jobs, containers, and agent experiments: final text goes to stdout, --json emits NDJSON events, and an optional append-only JSONL session can be resumed with full history. It is MIT licensed, about 837 lines of implementation Go, and designed to be forked and modified.
UNCUT takes a prompt from the command line and appends any piped stdin (for example a git diff or a log file) verbatim. It reads AGENTS.md from the workspace root unless --no-agents is passed, adds it to the system prompt, and sends a non-streaming Chat Completions request to the OpenAI-compatible endpoint in UNCUT_BASE_URL. Model output text is printed, and tool calls are executed: read_file returns an entire UTF-8 text file, write_file writes complete contents and creates parent directories, replace substitutes exactly one occurrence (zero or several matches fail), and run_command returns the exit code plus complete combined stdout/stderr using /bin/sh -c on Unix and cmd.exe /D /S /C on Windows. File tools are confined to the workspace; shell commands are not. With --session, each new message and tool result is appended and synced to a JSONL file and resumed intact on the next invocation. A --json run emits user, assistant, assistant_meta, tool, and finally done or error records. If the provider reports finish_reason=length or max_tokens, UNCUT exits with code 3 rather than presenting a partial answer as success.
- Add a repair step to CI: run uncut "Run the tests and fix the failure" so the model reads code, edits files, and runs tests, treating exit codes 3 and 4 as pipeline failures.
- Review code inside a shell pipeline: git diff | uncut "Review this diff. Do not edit files." yields plain-text findings in a terminal or script.
- Point it at a local Ollama server such as qwen3:8b to explain or lightly modify a repository without sending source to an external API.
- Run untrusted tasks inside a disposable container while using the four tools for the read-edit-run loop, keeping the full transcript in a session file for later review.
- Use it as a minimal baseline for agent research: a few hundred lines of Go, one provider protocol, one loop, easy to swap the model layer or add tools.
- Verify lossless transport against a self-hosted or proxied endpoint with python bench/proof.py, covering large files, large command output, session resume, and truncation behavior.
How do you install or deploy this agent?
Download the release binary for your platform and put it on PATH. Linux:
VERSION=0.1.1
ARCH=amd64 # use arm64 on ARM64
curl -fSLo uncut "https://github.com/Balanov/uncut/releases/download/v${VERSION}/uncut-linux-${ARCH}"
mkdir -p "$HOME/.local/bin"
install -m 0755 uncut "$HOME/.local/bin/uncut"
export PATH="$HOME/.local/bin:$PATH"
uncut --versionmacOS:
VERSION=0.1.1
ARCH=arm64 # use amd64 on Intel
curl -fSLo uncut "https://github.com/Balanov/uncut/releases/download/v${VERSION}/uncut-darwin-${ARCH}"
mkdir -p "$HOME/.local/bin"
install -m 0755 uncut "$HOME/.local/bin/uncut"
export PATH="$HOME/.local/bin:$PATH"
uncut --versionWindows PowerShell:
$Version = "0.1.1"
$Arch = "amd64" # use arm64 on ARM64
$Dest = "$env:LOCALAPPDATA\Programs\UNCUT"
New-Item -ItemType Directory -Force $Dest | Out-Null
Invoke-WebRequest -Uri "https://github.com/Balanov/uncut/releases/download/v$Version/uncut-windows-$Arch.exe" -OutFile "$Dest\uncut.exe"
$env:Path = "$Dest;$env:Path"
uncut --versionEach release ships checksums.txt; verify a download with:
VERSION=0.1.1
ARCH=amd64
curl -fSLO "https://github.com/Balanov/uncut/releases/download/v${VERSION}/checksums.txt"
grep "uncut-linux-${ARCH}$" checksums.txt | sha256sum -c -Binaries are not code-signed yet, so SmartScreen or Gatekeeper may warn. On macOS, after verifying, clear quarantine for this file only:
xattr -d com.apple.quarantine "$HOME/.local/bin/uncut"You can also install with Go 1.26+ or build from source:
go install github.com/Balanov/uncut/cmd/uncut@latestgit clone https://github.com/Balanov/uncut.git
cd uncut
go build -trimpath -ldflags="-s -w" -o bin/uncut ./cmd/uncutHow do you use this agent?
Set a model and API key, then pass a prompt:
export UNCUT_API_KEY="your-api-key"
export UNCUT_MODEL="your-model-id"
uncut "Inspect this repository and fix the failing tests"For another OpenAI-compatible provider, also set its base URL:
export UNCUT_BASE_URL="https://openrouter.ai/api/v1"Local Ollama example (the README records a smoke test with qwen3:8b; local endpoints need no API key by default):
ollama pull qwen3:8b
export UNCUT_BASE_URL="http://localhost:11434/v1"
export UNCUT_MODEL="qwen3:8b"
uncut "Explain this repository"Piped input is appended to the prompt verbatim:
git diff | uncut "Review this diff. Do not edit files."
cat failing-test.log | uncut "Find the likely cause"Emit NDJSON events or keep a resumable session:
uncut --json "Run the tests and fix the failure"
uncut --session .uncut/work.jsonl "Start the refactor"
uncut --session .uncut/work.jsonl "Continue with the tests"Useful flags: --cwd sets the workspace, --max-steps caps model calls (default 32), --max-tokens sets the provider output limit, --request-timeout sets the per-request timeout (default 10m), and --no-agents skips AGENTS.md. To run the lossless proof, which needs Python 3:
go build -o bin/uncut ./cmd/uncut
python bench/proof.py ./bin/uncutWhat are this agent's strengths and limitations?
- Predictable behavior by design: no truncation, summarization, pruning, or rewriting of prompts, file contents, and command output; the full history is resent every call.
- Tiny and portable: a single roughly 7 MB static Go binary for Linux, macOS, and Windows on amd64 and arm64, with no runtime or third-party Go dependencies.
- Provider-neutral: it only needs an OpenAI-compatible Chat Completions endpoint, so local Ollama servers and hosted services both work.
- Failures are explicit: provider truncation exits with code 3, hitting the step limit exits with code 4, and invalid UTF-8 is rejected rather than silently replaced.
- Fits automation: final text on stdout, structured NDJSON with --json, and append-only JSONL sessions that resume with complete history.
- Small MIT-licensed codebase: about 837 lines of implementation Go, one loop, one protocol, four tools, easy to audit and fork.
- Not a sandbox: run_command executes with your OS user's permissions and workspace path checks do not constrain shell commands, so untrusted tasks need a disposable container.
- No streaming and no image input; it handles text plus tool calls only, and when context or output limits are exceeded it fails explicitly instead of compacting or chunking.
- Depends on the model's tool-calling ability; the README states tool-call behavior depends on the model, so results vary and you may need to switch models.
- Session files can contain source code, command output, and secrets; there is no built-in encryption or redaction, only the guidance to store them carefully.
- On Windows, utilities that emit UTF-16 or code-page output are rejected rather than converted, so commands must be configured to emit UTF-8.
- Release binaries are not code-signed, so SmartScreen or Gatekeeper may warn and you must verify the SHA-256 checksum yourself.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| UNCUT This agent | 56 · Major gaps | — | ★ 600 | 2d ago | Go | OpenAI API |
| Dexto | 51 · Major gaps | CLIFree + model costs | ★ 660 | 1d ago | — | Claude Code · OpenAI API · Claude API |
| OmniGet Desktop Agents & Downloader | 71 · Some gaps | Desktop appFree + model costs | ★ 14k | 1mo ago | Rust | Codex · Claude Code · OpenAI API · Claude API |
| zot Coding Agent | 59 · Major gaps | CLIFree + model costs | ★ 356 | today | Go | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
README explicitly states UNCUT is not a sandbox: run_command executes arbitrary shell commands with the OS user's permissions, and workspace checks do not constrain shell access, so least_privilege scores 1 (disclosed but unenforced). There is no approval popup or confirmation mechanism, so user_confirmation is 0. Data-flow transparency is decent: full conversation sent each call, no telemetry, no truncation, session files may contain secrets, scoring 2. Sensitive data handling is a single warning that session files may contain code/output/secrets with no encryption or redaction, scoring 1. go.mod has no third-party dependencies and CI pins action versions, so dependency_security scores 2. External effects: no auto-commit or retries, but shell can cause arbitrary side effects with no rollback, so external_effects is 1 and rollback is 0. Source attribution is only README and LICENSE authorship with an unverified publisher, scoring 1.
README's descriptions of exit codes, truncation failures, session resume, and UTF-8 rejection are internally consistent, and both CI and release workflows run go test, go vet, and the proof script, so self_consistency scores 2. Dependency availability: only Go 1.26+ and the standard library, plus Python 3 for the proof, no third-party packages, scoring 2. Failure messages are backed by an explicit exit-code table (0-4) and error semantics, scoring 2. No tests were executed, so no credit is taken from execution.
Targets shell pipelines, CI, containers, and agent experiments with a clear audience, scoring 2. Capability boundaries are thoroughly documented: no TUI, no plugins, no background agents, no auto-retry, no context compaction, no images, non-streaming, scoring 3. Trigger precision relies only on natural-language prompts and --max-steps with no structured triggers or selectors, scoring 1. Environment fit covers Linux/macOS/Windows on two architectures and notes the Windows UTF-16 output issue, scoring 2.
README is well structured with install, configuration, tools, exit codes, and safety sections, scoring 2 for information architecture. Install notes are detailed with checksum verification and source builds, scoring 3. Naming stability: version hardcoded as 0.1.1 with no changelog, scoring 1. Examples and FAQ include quick start and pipeline examples but no dedicated FAQ, scoring 2. Known limitations are extensive (not a sandbox, unsigned binaries, Windows encoding, context limits), scoring 3. LICENSE is full MIT text, scoring 3. Versioning/changelog is absent, scoring 1. Maintenance responsibility is a single author with no governance or support commitment and an unverified publisher, scoring 1.
Output usability: final text to stdout and NDJSON events via --json suit pipeline consumption, scoring 2. Marginal value: a 7 MB static binary with four tools and lossless transport is a clear differentiator for CI/container use, scoring 2. Cost-benefit: no third-party deps and single-binary deployment are cheap, but sending the full conversation each call inflates token cost, scoring 2.
claim_traceability: the lossless claim points to bench/proof.py and BENCHMARKS.md, so it is traceable, scoring 2. cross_source_corroboration: only README and CI workflows corroborate each other; BENCHMARKS.md and bench files are not provided, scoring 1. fact_inference_separation: README distinguishes transport tests from model-quality benchmarks and states it cannot control provider-side processing, scoring 2.
- Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- UNCUT is not a sandbox: run_command executes arbitrary shell commands with the current user's permissions, and workspace checks do not constrain shell access; run untrusted tasks in a disposable container.
- There is no approval or confirmation mechanism; the model can write files and run commands autonomously with no rollback or auto-commit, so review sessions and changes yourself.
- Session JSONL files may contain source code, command output, and secrets; README only warns, with no encryption or redaction, so avoid committing them.
- The publisher is not verified by the FollowAgents registry and binaries are unsigned; verify checksums.txt before installing.
- The full conversation is sent on every call, which inflates token cost and context-limit risk for long sessions.
- This is a static source review; no tests or proof script were executed, so confidence is low.
- BENCHMARKS.md and bench/ files referenced by README were not provided in the evidence, so their measurements cannot be cross-checked.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
UNCUT 0.1.1 A patch release focused on Windows reliability and reproducible evidence. Fixed - run_command now preserves quoted cmd.exe commands, including executable paths with spaces and quoted arguments. Prove the lossless contract - New dependency-free bench/proof.py drives the real CLI through six scenarios: large UTF-8 input, complete combined stdout/stderr, exact edits, full-history resume, provider truncation, step limits, and invalid UTF-8. - CI runs this proof on Linux, macOS, and Windows. …View on GitHub ↗ -
Release notes excerpt
Full Changelog: https://github.com/Balanov/uncut/commits/v0.1.0View on GitHub ↗