# How to Customize the system_message in Open Interpreter: 4 Methods Explained

> Customize Open Interpreter system_message for tailored behavior. Explore 4 effective methods including Python, CLI flags, profiles, and custom instructions.

- Repository: [Open Interpreter/open-interpreter](https://github.com/openinterpreter/open-interpreter)
- Tags: how-to-guide
- Published: 2026-03-05

---

**You can customize the system_message in Open Interpreter by setting `interpreter.system_message` in Python, using the `--system_message` CLI flag, creating a reusable profile file, or appending instructions with `--custom_instructions`.**

The `system_message` is the core prompt that defines Open Interpreter's behavior, capabilities, and output format for every interaction. In the openinterpreter/open-interpreter repository, this message is fully customizable through multiple entry points, allowing you to tailor the AI's personality, safety policies, and coding style to your specific workflow.

## What Is the system_message?

The **system message** is the initial prompt sent to the language model on every request. It tells the model who it is, what it may do, and how it should format its output. According to the source code in [`interpreter/core/default_system_message.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/default_system_message.py), the default system message is a formatted f-string that dynamically inserts your operating system, username, and working directory to ground the model in your local environment.

## Where the system_message Is Defined and Stored

When you instantiate Open Interpreter, the constructor in [`interpreter/core/core.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/core.py) (lines 68-69) receives `system_message=default_system_message` and stores it as `self.system_message`. This instance attribute is read directly by the response pipeline in [`interpreter/core/respond.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/respond.py) (line 26) every time the interpreter generates a response, meaning any change to the attribute is immediately reflected in the next LLM call.

## 4 Methods to Customize the system_message

You can alter the system message through four distinct mechanisms, ranging from temporary runtime changes to permanent configuration files.

### 1. Runtime Assignment in Python

The simplest way to customize the system_message is to assign it directly to the singleton interpreter instance in your Python code or Jupyter notebook. This change takes effect immediately for all subsequent chat calls.

```python
from interpreter import interpreter  # the singleton instance

interpreter.system_message = """
You are a helpful data-science assistant. When you write code, always
include a brief comment describing each step.
"""

interpreter.chat("Plot the histogram of the 'mpg' column from the 'auto-mpg.csv' file.")

```

### 2. CLI Flag (--system_message)

When launching Open Interpreter from the command line, use the `--system_message` (or `-sm`) flag defined in [`interpreter/terminal_interface/start_terminal_interface.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/terminal_interface/start_terminal_interface.py) (lines 46-50) to replace the default prompt entirely.

```bash
interpreter --system_message "You are a terse Unix-shell expert. Output only the command."

```

You can combine this with `--custom_instructions` to layer additional constraints without rewriting the entire base prompt.

### 3. Profile Configuration Files

For permanent customizations, create a profile file in `~/.open-interpreter/profiles/` or use the defaults located in `interpreter/terminal_interface/profiles/defaults/` (such as [`assistant.py`](https://github.com/openinterpreter/open-interpreter/blob/main/assistant.py) or [`llama3.py`](https://github.com/openinterpreter/open-interpreter/blob/main/llama3.py)). These Python files set `interpreter.system_message` directly and are loaded by [`interpreter/terminal_interface/profiles/profiles.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/terminal_interface/profiles/profiles.py).

Create `~/.open-interpreter/profiles/myprofile.py`:

```python

# myprofile.py

interpreter.system_message = """
You are a friendly Python tutor. Explain every line of code you output.
"""

interpreter.computer.system_message = ""  # Optional: suppress the built-in computer hint

```

Run it:

```bash
interpreter --profile myprofile.py

```

### 4. Appending Custom Instructions (--custom_instructions)

If you want to keep the default system message intact but add specific constraints, use the `--custom_instructions` (or `-ci`) flag defined in [`interpreter/terminal_interface/start_terminal_interface.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/terminal_interface/start_terminal_interface.py) (lines 39-44). This appends text to the system message rather than replacing it.

```bash
interpreter --custom_instructions "Always wrap Python code in triple backticks."

```

## How the Final Prompt Is Assembled

Understanding how Open Interpreter constructs the final prompt helps predict how your customizations will interact. In [`interpreter/core/respond.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/respond.py) (line 26), the system message is built through the following concatenation logic:

```python
system_message = interpreter.system_message
if hasattr(language, "system_message"):
    system_message += "\n\n" + language.system_message
system_message += "\n\n" + interpreter.custom_instructions
if interpreter.computer.system_message not in system_message:
    system_message = system_message + "\n\n" + interpreter.computer.system_message

```

This means your `system_message` forms the base, followed by language-specific additions, then your `custom_instructions`, and finally the computer's system message if not already present. Any change to `interpreter.system_message` or `interpreter.custom_instructions` is reflected in every subsequent model call.

## Summary

- The **system_message** is stored as `self.system_message` in the `OpenInterpreter` class ([`interpreter/core/core.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/core.py)) and defaults to the template in [`interpreter/core/default_system_message.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/default_system_message.py).
- You can **customize the system_message** through four methods: direct Python assignment, the `--system_message` CLI flag, profile configuration files, or the `--custom_instructions` flag for appending text.
- The final prompt sent to the LLM is assembled in [`interpreter/core/respond.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/respond.py) by concatenating the base system message, language-specific messages, custom instructions, and computer system messages.
- Changes take effect immediately for runtime assignments or on the next request for CLI and profile configurations.

## Frequently Asked Questions

### What is the default system_message in Open Interpreter?

The default system message is defined in [`interpreter/core/default_system_message.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/default_system_message.py) as a formatted f-string that dynamically inserts your operating system, username, and working directory. It instructs the model that it is a code-interpreting assistant capable of executing commands on your local machine.

### Can I combine multiple methods to customize the system_message?

Yes, customization methods are layered. The CLI `--system_message` flag or a profile file sets the base prompt, while `--custom_instructions` appends additional constraints. Runtime Python assignments override previous values for the current session, with the final assembly occurring in [`interpreter/core/respond.py`](https://github.com/openinterpreter/open-interpreter/blob/main/interpreter/core/respond.py) before each LLM call.

### How do I permanently save a custom system_message?

Create a profile file in `~/.open-interpreter/profiles/` (e.g., [`myprofile.py`](https://github.com/openinterpreter/open-interpreter/blob/main/myprofile.py)) that sets `interpreter.system_message` to your desired prompt. Launch Open Interpreter with `interpreter --profile myprofile.py` to load your configuration automatically.

### Does modifying the system_message affect code execution safety?

Changing the system_message alters the model's behavior and instructions, but it does not bypass Open Interpreter's underlying safety mechanisms or sandboxing. The model may interpret relaxed instructions differently, so always review generated code before execution regardless of how you customize the system prompt.