yolop

Terminal coding agent · Open source

Point it at your repo and get out of the way.

Yolop is a terminal coding agent that's autonomous by default. Named after the Ukrainian йолоп — a fool — because it doesn't believe in per-tool approval pop-ups. It plans, edits, runs, and verifies, and asks for consent only when it actually matters.

View on GitHub ↗

1 binary

plan · edit · run · verify

7 providers

bring your own model

MIT

licensed, in Rust

system › workspace: ~/acme-api

system › model: OpenAI · gpt-5.6-sol

you › fix the flaky timeout in the run executor and add a regression test

agent › I'll map the executor, patch the timeout, and add a test.

tool › 0 of 3 todos completed ○ Find timeout ○ Fix root cause ○ Add test

tool › ✓ Repo map 142 symbols across 18 files

tool › ✓ Grep /timeout/ (7 matches)

tool › ✓ Read crates/run/src/executor.rs (60/240 lines)

tool › ✓ Edit crates/run/src/executor.rs (2 edits)

diff › - let deadline = now + Duration::from_secs(30);

diff › + let deadline = now + cfg.timeout.unwrap_or(DEFAULT_TIMEOUT);

tool › ✓ Write crates/run/tests/timeout.rs (48 lines)

tool › ✓ Bash `cargo test -p run` exit=0

test result: ok. 14 passed; 0 failed

agent › Root cause was a hard-coded 30s deadline; it now honors cfg.timeout. Want me to commit?

The Yolop way

Plans, edits, runs, and verifies — in one binary.

A terminal coding agent built on the Everruns Runtime. Autonomous by default, with persistent sessions, agent skills, MCP servers, and editor integration.

Autonomous by default

Runs writes, edits, deletes, and bash commands without prompting — behind a standing write blocklist that rejects .git/, node_modules/, target/ and friends at any depth.

Soft approval, not pop-up fatigue

An AI-judgement layer pauses for spoken consent only at critical moments, and writes an audit trail. Levels: protective / normal / off.

Goal loops

/goal <condition> keeps working across turns until a separate evaluator model confirms the condition is met — even in one-shot mode.

Plans and verifies its own work

write_todos with loop detection, and a shell that actually runs your tests, builds, and linters to check the result.

Persistent, resumable sessions

Durable per-session event logs on disk. Pick up where you left off with --session <id>; results survive a restart.

Runs where you work

Interactive TUI, one-shot --print for scripts and CI, or inside your editor over the Agent Client Protocol.

Tools & context

What comes in the box.

Repo map + AST grep. repo_map and repo_symbols build a multi-language symbol overview; structural ast_grep spans Rust, Python, TypeScript, Go, C#, and more.

Optional LSP. Real language servers — rust-analyzer, pyright, gopls, clangd — behind diagnostics, definition, references, and rename. Off by default; opt in per project.

Background tasks that wake it. spawn_background runs detached, streams to a log, and proactively wakes the agent when a task finishes while it is idle.

Infinity context + memory. Old history is trimmed from the live prompt but stays queryable, and a structured MEMORY.md keeps what matters.

MCP, skills, and hooks. Wire in stdio and HTTP MCP servers, drop in SKILL.md files, and gate behavior with deterministic hooks.

Web access, built in. web_fetch turns a page into clean markdown with DNS-pinned SSRF protection, and duckduckgo_search needs no API key.

Git worktree isolation. Each session can work on its own branch in an isolated directory, so your main checkout stays untouched.

Bring your own model

Choose your provider.

Seven providers behind one flag. Yolop auto-detects credentials from your environment and uses the first it finds.

OpenAIgpt-5.6-soldefault

Anthropicclaude-opus-4-8

Codex subscriptionChatGPT login

OpenRouteropenai/gpt-5.6-sol

Googlegemini-2.5-flash

Ollamallama3.2 · local

Customany OpenAI-compatible

Pick one with --provider, override the model with -m. Resolution order: OpenAI → Codex → Anthropic → OpenRouter → Google → Ollama → Custom.

Autonomous, not reckless

The limits are specific and enforced.

Autonomy is the default, but it runs inside concrete boundaries.

Blocklist

Protected paths, always.

Writes into .git/, node_modules/, target/, dist/, build/, .venv/ and more are rejected at any depth.

Shell caps

Bounded execution.

Commands run from workspace root with a 120s wall-clock timeout and a 1 MiB per-stream output cap; large output spills to disk.

Consent

Spoken approval + audit.

Soft approval pauses at critical moments and records every decision to the session log via record_approval.

// straight from the docsSoft approval is not a sandbox. It asks the model to pause at the right time, but it does not mechanically block a tool call. For deterministic enforcement, use hooks.— docs/features/approvals.md

Ways to run it

Same agent, three surfaces.

One binary, run in the shape that fits the task.

Interactive TUI

A scrolling transcript, multiline composer, slash commands, and a background-tasks panel. The default when you type yolop.

$ yolop

One-shot / CI

Headless --print mode prints to stdout with no TUI, for scripts, pipelines, and cron.

$ yolop -p "…"

In your editor

Speaks the Agent Client Protocol over stdio. One command auto-configures Zed.

$ yolop into zed

Quick start

Running in three lines.

Install.

Homebrew on macOS & Linux, or cargo install yolop --locked from source.

Point it at a repo.

cd into your project — or use -C /path/to/repo to work elsewhere.

Run yolop.

First launch with no credentials opens a guided setup: provider → credentials → model.

Run it on your own repo.

Yolop plans, edits, runs, and verifies while you review the diff. It's open source, MIT-licensed, and still experimental — one brew install away.

brew install everruns/tap/yolop Read the docs ↗