Killian Lucas — Open Interpreter and the natural language OS

by Ray Svitla

in September 2023, Killian Lucas released Open Interpreter and the internet lost its mind for about two weeks. the pitch was irresistible: ChatGPT’s Code Interpreter, but running locally on your computer. no sandbox. no upload limits. full access to your files, your terminal, your entire system.

“a natural language interface for computers.” that was the tagline. type what you want in English, the computer does it. the dream since the 1960s, now seemingly possible because LLMs can translate intent to code.

the repo hit 50K+ GitHub stars. everyone tried it. most people had the same experience: it worked amazingly for simple things, failed confusingly for complex things, and occasionally did something terrifying to your filesystem. classic v1 energy.

the vision

Lucas’s thesis is simple and radical: the command line and GUI are both interfaces designed for humans to learn. what if instead of learning the interface, the interface understood you?

not a chatbot that generates code for you to copy-paste. not an assistant you ask questions. an agent that controls your computer directly — running shell commands, writing files, installing packages, navigating the web — all from a single natural language conversation.

> open interpreter

● hey, can you find all PDFs in my downloads 
  from the last week and organize them into 
  folders by topic?

sure, let me take a look at your Downloads folder...
[runs: find ~/Downloads -name "*.pdf" -mtime -7]
I found 23 PDFs. let me read each one to determine 
the topic...

the computer as conversation partner rather than tool you operate. input in human language, output in human results. everything in between handled by the AI.

the reality check

Open Interpreter works well for tasks that map cleanly to shell commands. file manipulation, data processing, package installation, text transformation. things where the gap between “what you said” and “what to execute” is small.

it struggles with ambiguity. “organize by topic” — what topics? whose taxonomy? how many folders? a human assistant would ask clarifying questions. Open Interpreter sometimes asks, sometimes guesses, sometimes creates a folder structure that makes sense only to the model that created it.

the safety question is the elephant in the terminal. Open Interpreter runs commands with your user’s permissions. “delete the old files” could mean different things depending on context. the model doesn’t always guess right. a wrong guess with rm is permanent.

Lucas added confirmation prompts — the agent shows you the command before executing. but this creates a different problem: if you have to review every command, you’re just using a fancier command line. the value of natural language control drops significantly when you need to verify every translation.

the influence

Open Interpreter’s real impact might be cultural rather than technical. it demonstrated that natural language computer control was possible enough to be exciting, which triggered a wave of similar projects and pushed major companies to build their own versions.

Anthropic’s computer use feature, OpenAI’s code interpreter improvements, Apple’s enhanced Siri — none of these are directly descended from Open Interpreter, but they exist in a landscape it helped define. the idea that your computer should understand plain English instructions went from science fiction to expected feature in about eighteen months.

Claude Code itself owes something to this lineage. the idea of an AI agent that runs shell commands, edits files, and controls your development environment — that’s Open Interpreter’s vision, scoped to a specific domain and executed with more guardrails.

the deeper question

what Lucas is really building toward is a rethinking of the entire human-computer interface. not “better CLI” or “smarter GUI” but a third option: conversational computing where the interface adapts to you rather than you adapting to the interface.

the convivial technology angle is interesting here. Ivan Illich would probably have complicated feelings about natural language computing. on one hand, it lowers the barrier to computer use — you don’t need to learn arcane syntax. on the other hand, it adds a layer of interpretation between you and the machine. when the computer does something wrong, debugging “why did it interpret my words that way” is harder than debugging “why did my command do that.”

there’s a loss of literacy in the translation. a command-line user understands what find . -name "*.pdf" -mtime -7 does and can modify it. a natural language user who says “find recent PDFs” might not understand the underlying operation well enough to fix it when the definition of “recent” doesn’t match their expectation.

where it stands

Open Interpreter continues to develop, though the hype cycle has moved on. the project has evolved toward a more structured approach — defined tools, clearer safety boundaries, better handling of ambiguity.

the natural language OS vision isn’t dead. it’s just harder than the initial excitement suggested. the gap between “this works for demos” and “this works reliably enough to trust with your computer” is wider than most people expected. closing that gap is the actual work, and it’s less glamorous than the viral launch.

would you trade precise control over your computer for the convenience of talking to it — knowing the translation layer will sometimes get it wrong?

→ browser agents — the web version of this vision → agent guardrails — keeping agents safe → agentic design patterns — patterns for agent systems

Ray Svitla stay evolving