> For the complete documentation index, see [llms.txt](https://docs.darcyiq.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.darcyiq.com/core-features/darcy-os.md).

# DarcyOS

DarcyOS is the operating system that powers DarcyIQ Chat and Agents — a full computer-use microVM giving Darcy a real Linux environment where she can write her own scripts, execute code, install packages, process files, and produce deliverables directly inside your conversation.

{% hint style="success" %}
**From answering questions to actually getting things done**: Ask Darcy to clean a CSV, generate charts, and produce a polished report — all in one conversation, with real code running behind the scenes.
{% endhint %}

## Overview

DarcyOS gives every conversation access to a sandboxed Linux environment with Python, Node.js, common data tools, and a persistent workspace. Darcy uses it autonomously whenever a task benefits from real execution — analysis, transformations, file processing, scripting, and multi-step deliverables.

| Feature                  | Capability                                                                | Business Impact                                       |
| ------------------------ | ------------------------------------------------------------------------- | ----------------------------------------------------- |
| **Full microVM**         | Real Linux environment with Python, Node, and standard packages           | Darcy executes work instead of just describing it     |
| **Script Authoring**     | Darcy writes scripts on the fly to fit your task                          | No need to specify exact tools — describe the outcome |
| **File Processing**      | Read, transform, and produce files directly in chat                       | CSV cleanup, format conversion, batch operations      |
| **Persistent Workspace** | Each conversation gets its own workspace that survives across turns       | Iterate on results without re-uploading inputs        |
| **Package Installation** | Darcy installs additional Python or Node packages when a task requires it | Specialized libraries available on demand             |
| **Agents Integration**   | Agents and scheduled runs use the same DarcyOS environment                | Automated workflows can produce real outputs          |

## How It Works

When you ask Darcy to do something that needs execution, DarcyOS spins up automatically for your conversation. Darcy decides when to use it — you don't need to invoke it explicitly.

{% stepper %}
{% step %}
**Describe Your Task** Ask Darcy in chat as you normally would. For example: *"Take this sales CSV, drop rows with missing emails, and give me a chart of revenue by region."*
{% endstep %}

{% step %}
**Darcy Plans and Executes** Darcy writes the necessary scripts, installs any required packages, and runs them inside DarcyOS. You'll see the steps streamed live in the conversation.
{% endstep %}

{% step %}
**Iterate in the Same Workspace** Follow-up requests — *"Sort the chart by revenue descending"* or *"Now export it as a PNG"* — operate on the same workspace, so Darcy doesn't have to start from scratch.
{% endstep %}

{% step %}
**Collect Your Deliverables** Generated files land in the conversation's workspace. Open them inline, download them, or attach them to a project.
{% endstep %}
{% endstepper %}

## The Workspace

Every conversation has its own workspace mounted inside DarcyOS. Open the workspace from the chat side panel to browse files, upload inputs, and download deliverables.

| Folder         | Purpose                                                                  |
| -------------- | ------------------------------------------------------------------------ |
| **user-files** | Files you upload for Darcy to use as inputs                              |
| **artifacts**  | Deliverables Darcy produces and publishes back to you                    |
| *Other*        | Anything else Darcy creates while working — scripts, intermediates, logs |

You can upload files at any time. Darcy will pick them up automatically the next time it runs against the workspace.

## Using DarcyOS in Chat

DarcyOS activates whenever Darcy decides a task benefits from execution. Common patterns:

| Request Type         | What Darcy Does                                                 |
| -------------------- | --------------------------------------------------------------- |
| **Data Analysis**    | Loads your file, cleans it, and runs the analysis you asked for |
| **File Conversion**  | Transforms between formats (CSV ↔ Excel, Markdown ↔ DOCX, etc.) |
| **Chart Generation** | Builds matplotlib / Plotly charts and returns them as images    |
| **Bulk Operations**  | Renames, reorganizes, or processes many files in one pass       |
| **Code Execution**   | Runs Python or shell snippets and shows the output              |
| **Report Building**  | Combines multiple inputs into a polished deliverable            |

You don't need a special prompt — describe the outcome you want and Darcy will reach for DarcyOS when it's the right tool.

## DarcyOS in Agents

Agents run on the same DarcyOS environment as Chat. When you build an agent for a task that involves execution — data pulls, report generation, file transformations — that agent can:

* Write and run scripts to complete its assigned task
* Use any installed Python or Node tooling
* Produce real file deliverables that get attached to the run
* Operate inside its own isolated workspace

This is what makes scheduled agents genuinely "set and forget" — a daily reporting agent can pull data, transform it, and publish a polished output without a human in the loop.

See [Agents](/core-features/agents.md) for more on building and scheduling agents.

## DarcyOS in Workflows

[Workflows](/build/ai-workflows.md) can leverage DarcyOS at any step where execution is needed. This is especially useful for:

* **Multi-step transformations** — chain together extracts, cleans, and joins
* **Code-driven steps** — embed a script as part of an automated pipeline
* **File pipelines** — accept a file, process it, and emit a deliverable as the next step's input

See [Creating Efficient Workflows](/build/ai-workflows/creating-efficient-workflows.md) for design guidance.

## Use Cases

### Data & Analytics

* Clean and reshape CSVs, Excel sheets, or JSON dumps
* Run statistical analyses and return charts in the conversation
* Join data across multiple uploaded files

### Content & Documents

* Convert between document formats while preserving structure
* Extract text, tables, or images from large files
* Apply consistent formatting across a batch of documents

### Engineering & DevOps

* Run quick scripts against logs or config files
* Validate or generate JSON, YAML, or other structured formats
* Prototype small automations directly in chat

### Reporting

* Build periodic reports from raw data inputs
* Produce charts, summaries, and downloadable deliverables
* Schedule the whole flow through an agent for hands-off delivery

## Best Practices

1. **Describe outcomes, not tools**: Tell Darcy *what* you need, not which library to use — it picks tools that fit
2. **Upload inputs once**: The workspace persists across turns, so re-iterate without re-uploading
3. **Iterate in the same conversation**: Follow-ups are faster because Darcy already has the context and files
4. **Combine with Skills**: Pair DarcyOS with a [Skill](/core-features/skills.md) that encodes your team's conventions for outputs (naming, formatting, structure)
5. **Schedule it**: Once a workflow works in chat, wrap it in an [Agent](/core-features/agents.md) and schedule it to run on its own

{% hint style="info" %}
**Pro Tip**: DarcyOS shines on tasks that would normally bounce between chat, a spreadsheet, and a script. If you find yourself copying data out to do something with it, ask Darcy to do it in DarcyOS instead.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.darcyiq.com/core-features/darcy-os.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.