Add article: Run AI Engineers Inside Daytona Workspaces

articles/20260908_run_ai_engineers_inside_daytona.md

@@ -0,0 +1,215 @@
+---
+title: 'Run AI Engineers Inside Daytona Workspaces'
+description:
+  'Set up Omni Engineer and Claude Engineer in reproducible Daytona
+  workspaces using dev containers, and put an AI engineer to work on a
+  real project in minutes.'
+date: 2026-09-08
+author: 'Furox'
+tags: ['daytona', 'ai-agents', 'devcontainer', 'claude', 'openrouter']
+---
+
+# Run AI Engineers Inside Daytona Workspaces
+
+# Introduction
+
+AI engineering assistants have quietly become full members of the
+development team. Tools like [Omni
+Engineer](https://github.com/Doriandarko/omni-engineer) and [Claude
+Engineer](https://github.com/Doriandarko/claude-engineer) can read your
+codebase, create and edit files, run searches, execute generated code,
+and manage their own tooling — all from a command line. They are not
+chatbots bolted onto an editor; they are agents that act on a project.
+
+Giving an autonomous agent access to your project raises the same
+question infrastructure teams solved years ago for humans: where should
+this work actually run? Running an agent directly on your laptop mixes
+its file edits, package installs, and network calls with your personal
+environment. [Daytona](https://github.com/daytonaio/daytona) answers
+that question with reproducible
+[workspaces](https://www.daytona.io/docs/create-a-workspace.html) —
+isolated, scriptable development environments that spin up from a Git
+URL in seconds, execute the [dev container
+specification](https://containers.dev/), and can be deleted without a
+trace when the job is done.
+
+In this article we will set up both engineers inside Daytona
+workspaces, wire up their API keys safely, and put Omni Engineer to
+work on a concrete task. Both repositories now ship a
+`devcontainer.json`, so Daytona can configure the entire toolchain —
+Python, dependencies, editor extensions, and port forwarding — without
+a single manual step.
+
+![Diagram of a Daytona workspace running AI engineers](/assets/20260908_run_ai_engineers_inside_daytona_img1.svg)
+
+## TL;DR
+
+- **Reproducible agent environments**: both engineers now include a
+  `devcontainer.json`, so `daytona create` provisions everything.
+- **Isolation by default**: agent file edits and package installs stay
+  inside the workspace, not on your laptop.
+- **Two tools, one pattern**: Omni Engineer (OpenRouter, console) and
+  Claude Engineer (Anthropic, CLI + web UI) follow the same workflow.
+- **Ports handled for you**: Claude Engineer's web interface is
+  forwarded automatically.
+
+## What You Need Before Starting
+
+To follow along you should have:
+
+- [Daytona](https://www.daytona.io/) installed locally. The one-line
+  installer from the [repository
+  README](https://github.com/daytonaio/daytona) takes care of it.
+- An [OpenRouter](https://openrouter.ai/) API key for Omni Engineer, or
+  an [Anthropic](https://www.anthropic.com/) API key for Claude
+  Engineer. Both have free-tier friendly models to start with.
+- Roughly five minutes.
+
+**Key Point:** The workspace never needs credentials baked into the
+image. API keys are supplied at runtime, so they never end up in a
+container layer.
+
+## Step 1: Create the Workspace
+
+The whole setup starts with a single command:
+
+```bash
+daytona create https://github.com/Doriandarko/omni-engineer --code
+```
+
+Daytona clones the repository into a fresh sandbox, reads its
+`.devcontainer/devcontainer.json`, and builds the environment it
+describes: Python 3.11 on the
+[devcontainers](https://containers.dev/implementors/images/) base
+image, `pip install -r requirements.txt` as the post-create command,
+and the recommended VS Code extensions for Python work. When the
+command finishes, you land inside the workspace with everything
+installed.
+
+The `--code` flag drops you straight into VS Code connected to the
+sandbox. The same flow works for Claude Engineer:
+
+```bash
+daytona create https://github.com/Doriandarko/claude-engineer --code
+```
+
+Its dev container additionally forwards port `5000`, which the web
+interface uses later in this article.
+
+## Step 2: Configure the API Key
+
+Omni Engineer loads its configuration from a `.env` file, following the
+[python-dotenv](https://pypi.org/project/python-dotenv/) convention. In
+the workspace terminal:
+
+```bash
+cp .env.example .env
+```
+
+Then edit `.env` and set your key:
+
+```env
+OPENROUTER_API_KEY="sk-or-v1-..."
+```
+
+Claude Engineer uses the same pattern with Anthropic credentials:
+
+```env
+ANTHROPIC_API_KEY=sk-ant-...
+E2B_API_KEY=your_e2b_api_key  # optional, enables the code execution tool
+```
+
+**Note:** Because the key lives in the workspace's `.env` file and not
+in your shell profile, destroying the workspace destroys the key
+reference with it. Nothing sensitive lingers on your machine.
+
+## Step 3: Put Omni Engineer to Work
+
+Launch the console from the workspace:
+
+```bash
+python main.py
+```
+
+Omni Engineer opens an interactive session backed by an OpenRouter
+model of your choice (switch anytime with `/change_model`). Let's give
+it a real job — a tiny price-checking script with a bug in it:
+
+```text
+/new prices.py
+Create a script that reads prices from items.csv (columns: name,price)
+and prints the three most expensive items, formatted as a table.
+```
+
+The agent creates the file, but suppose the first version sorts as
+strings so `9.99` beats `10.00`. Add the file to context and have it
+fixed:
+
+```text
+/add prices.py
+The sort treats prices as strings. Fix it to sort numerically and show
+me the diff.
+```
+
+Omni Engineer applies a multi-line edit and displays a colored diff —
+confirm it with `/diff`, and if you dislike the change, `/undo
+prices.py` reverts the file. This edit → review → undo loop is the
+reason to keep the agent inside a disposable workspace: an undo that
+misses something costs you nothing, because `daytona delete` erases the
+whole experiment.
+
+## Step 4: Claude Engineer and the Web Interface
+
+Claude Engineer's distinguishing feature is
+[self-generated tools](https://github.com/Doriandarko/claude-engineer):
+when a task needs a capability it lacks, the agent writes the tool,
+registers it, and uses it in the same session. Inside the workspace you
+have two options:
+
+```bash
+# interactive CLI
+python ce3.py
+
+# or the web interface
+python app.py
+```
+
+With the dev container forwarding port `5000`, open the forwarded
+address in your browser and the full chat interface is available —
+tools panel, conversation view, and file operations included. The
+[E2B code execution
+tool](https://e2b.dev/docs) deserves a special mention here: with an
+optional `E2B_API_KEY` set, Claude can run the Python it writes in a
+secure second sandbox and show you the actual output.
+
+## Choosing Between the Two
+
+- **Omni Engineer** is a single-file console tool built around
+  [OpenRouter](https://openrouter.ai/), which means one key unlocks
+  models from many providers. Ideal for quick, script-like sessions.
+- **Claude Engineer** is a full framework on
+  [Anthropic](https://docs.anthropic.com/en/docs/intro-to-claude)
+  models with tool creation, linting, folder operations, and a web UI.
+  Ideal for longer, tool-heavy sessions.
+
+Both benefit identically from the Daytona treatment: one command to
+provision, one file to configure, one command to destroy.
+
+## Conclusion
+
+Running AI engineers in Daytona workspaces turns "an agent edited my
+repository" from a backup-restore story into a routine, disposable
+workflow. The dev containers added to both repositories make the setup
+a single `daytona create` away, keep API keys out of images, and give
+you a clean slate for every experiment. Try pointing the engineer at
+your own side project — and when the session gets messy, remember that
+`daytona delete` is the cheapest undo button you will ever use.
+
+## References
+
+- [Omni Engineer repository](https://github.com/Doriandarko/omni-engineer)
+- [Claude Engineer repository](https://github.com/Doriandarko/claude-engineer)
+- [Daytona documentation](https://www.daytona.io/docs/)
+- [Dev container specification](https://containers.dev/)
+- [Setting up a project with Cal.com and Supabase (Daytona
+  example)](https://www.daytona.io/dotfiles/how-to-set-up-a-project-with-cal-com-and-supabase)