Interference: The Italian Open Source coding agent

There are excellent coding agents out there. Some are powerful but proprietary, locked behind subscriptions and vendor APIs. Others are open source and remarkably well built. They all solve the same fundamental problem: an LLM that reads your codebase and acts on it.

So why build another one?

I did not set out to disrupt anything. I wanted to understand. I wanted to go through the process of building an agent from scratch: the loop, the tools, the permissions, the TUI. See what decisions emerge when you are not optimizing for a demo but for something you would actually use every day.

interference is the result. It is a terminal-native coding agent built in TypeScript and Bun. It is MIT licensed, open source in a way that invites you to read the code and change it, and one of very few coding agents you can install and run with your own API keys, on your own terms.

What it does

You type a prompt. It explores your codebase with tools like grep, glob, read, and webfetch. Then it acts: write, edit, bash through an agentic loop, with explicit permissions and a read-only Plan mode so nothing happens without your say-so.

It ships as a single command:

bun install -g interference-agent
interference

The stack

TypeScript on Bun. The agent loop runs on the Vercel AI SDK (ai v7) with multi-step tool calling, reasoning mode streaming, and token-level cost tracking with cache-hit awareness. The TUI is Ink 7.1 with React 19.2: static history, streaming responses, tool spinners, and a status footer.

It connects to 10 providers: DeepSeek, OpenAI, Anthropic (Claude), Zhipu (GLM), Moonshot (Kimi), Google (Gemini), Groq, xAI (Grok), Mistral, and OpenRouter. Plus any OpenAI-compatible endpoint you point it at. You bring your own keys. They stay on your machine.

What is inside

Tools. Eleven tools: read, ls, glob, grep, webfetch (URL fetching), write, edit, bash (with path containment and a deny list for dangerous commands), todowrite (structured task tracking), question (ask the user mid-execution), and task (delegate to subagents that run in parallel).

Permissions. allow/ask/deny rules enforced in code, not in the prompt. The model proposes; the system decides. Confirmation dialogs with arrow-key navigation and diff previews.

Agent registry. Three built-in subagents (explore, general, review) with declarative definitions. Custom agents definable in interference.json. Invoke multiple tasks in the same turn and they run in parallel.

Review agent. The /review command scans your working diff for bugs, security issues (hardcoded secrets, path traversal), and simplification opportunities. Runs on a cheap model, isolated from the main conversation.

Model catalog. Real-time pricing and context window data from a live catalog, with on-disk caching and an embedded offline snapshot. Cost tracking reflect actual API prices, not estimates.

Prompt caching. Anthropic opt-in ephemeral caching reduces input costs by ~90% from the second turn onward. Cache hit tracking across all providers.

Skills. An extensible skill system based on the Agent Skills format. Three skills ship with the agent. Drop a SKILL.md in your local directory and the agent picks it up automatically.

Sessions. Conversations saved per-project. Resume with --continue. Undo file changes through snapshots.

TUI. Static message history, streaming, tool spinners, status footer, model picker (grouped by provider), slash autocomplete, session browser, toast notifications. Diff view with green/red color coding and syntax highlighting.

Config file. Per-project interference.json for model, mode, permissions, instructions. Walk-up from cwd, env var overrides.

Why open source

I think coding agents will become infrastructure, like linters, formatters, and test runners. That infrastructure should be transparent.

interference is MIT licensed. You can read every line. You can change it. You can fork it, break it, improve it. The repo is small enough that you can read the entire agent loop in one sitting.

What I would love you to do

Try it. Break it. Open an issue. Send a pull request. Fork it and build your own version. The best outcome for this project is not adoption. It is that someone takes it apart, learns from it, and builds something better.

What is next

Local LLM support is the next major feature: auto-discovery of local servers (Ollama, LM Studio, MLX), hardware-aware model recommendations, and a setup wizard. The goal is a fully offline agent that runs on modest hardware.

There is also a structured task tracker, a web search tool, MCP integration for community tools, and many smaller ideas that come from actually using the agent every day. The iteration backlog is public: 18 iterations completed, all documented with written plans and completeness passes.

A note on how this was built

About 95% of the code in this repository was written by an AI coding agent. I defined the architecture, wrote the plans, made the decisions, and reviewed every line. But the actual implementation happened through an agent loop, iteration after iteration. This project is, in a real sense, a demonstration of what coding agents can already do today: take a clear specification and turn it into working software, under human direction.

If you find that interesting, or worrying, or both: good. That is exactly the conversation I wanted to start.

The repo is at github.com/ricciviero/interference. The landing page is at interferenceagent.com.