DEV Community: Arpan Dhara

🐧 WSL (Windows Subsystem for Linux) — Complete Setup & Command Guide

Arpan Dhara — Sat, 15 Aug 2026 06:56:24 +0000

🚀 A step-by-step guide to installing, configuring, and using Windows Subsystem for Linux (WSL) — including essential commands, Windows/Linux integration, and useful advanced features.

📚 Table of Contents

What is WSL?
Step 1 — Enable WSL Features
Step 2 — Check Your WSL Installation
Step 3 — Update WSL
Step 4 — List Installed Linux Distributions
Step 5 — See Available Distributions
Step 6 — Install a Linux Distribution
Step 7 — Uninstall a Distribution
Step 8 — Change the Default Distribution
Step 9 — Launch and Switch Between Linux Distributions
Step 10 — Exit and Shut Down WSL
Step 11 — Access Windows Drives from Linux
Step 12 — Use Windows Commands from Linux
Step 13 — Run Windows Applications from Linux
Step 14 — Use VS Code with WSL
Step 15 — Open the Current Linux Directory in Windows Explorer
Step 16 — Run Linux Commands from Windows
Step 17 — Kali Linux Tweaks
🧠 Command Cheat Sheet
📖 Official Documentation

🐧 What is WSL?

Windows Subsystem for Linux (WSL) allows you to run a Linux environment directly on Windows without needing to set up a traditional dual-boot system or a separate full virtual machine.

With WSL, you can:

🐧 Run Linux distributions such as Ubuntu or Kali Linux.
💻 Use Linux commands directly from Windows.
🪟 Run Windows commands and applications from Linux.
📁 Access Windows files from Linux.
🛠️ Use development tools such as VS Code with a Linux environment.
🔄 Move between Windows and Linux workflows easily.

This guide is based on the commands and workflow in the accompanying WSL notes, expanded into a beginner-friendly Dev.to tutorial.

⚙️ Step 1 — Enable WSL Features

Before using WSL, make sure the required Windows features are enabled.

1. Open Windows Features

On Windows:

Press Win + R.
Type:

optionalfeatures

Press Enter.
In Turn Windows features on or off, enable:

✅ Virtual Machine Platform
✅ Windows Subsystem for Linux

Click OK.
Restart your PC when Windows asks you to.

💡 Why are these features required?

Windows Subsystem for Linux provides the Windows component required to run Linux environments.

Virtual Machine Platform provides virtualization support used by WSL 2.

🔁 A restart is important after enabling these Windows features.

🔍 Step 2 — Check Your WSL Installation

Open PowerShell or Windows Terminal and run:

wsl --status

What does it do?

wsl --status displays information about your WSL installation and configuration.

It is useful when you want to quickly check whether WSL is installed and see relevant version/configuration information.

Example

wsl --status

If WSL is working correctly, Windows will display information about the current WSL configuration.

🔄 Step 3 — Update WSL

To update WSL to the latest available version, run:

wsl --update

What does it do?

The command checks for and installs available updates for WSL.

Recommended workflow

If you are setting up WSL on a new machine, it is a good idea to update WSL before continuing:

wsl --update

📦 Step 4 — List Installed Linux Distributions

To see Linux distributions installed on your Windows system:

wsl --list

You may also use:

wsl -l

What does it do?

It lists the Linux distributions currently installed under WSL.

For example, you might have:

Ubuntu
kali-linux

🟢 Show Currently Running Distributions

Use:

wsl --list --running

or:

wsl -l --running

What does it do?

This shows only the Linux distributions that are currently running.

This is useful when you have several distributions installed and want to know which ones currently have active WSL instances.

🔎 Show Detailed Distribution Information

Use:

wsl --list --verbose

or:

wsl -l -v

What does it show?

The verbose list provides additional information about installed distributions, including their WSL version and whether they are currently running.

This is particularly useful for checking whether a distribution is using WSL 1 or WSL 2.

🌐 Step 5 — See Available Distributions

To see Linux distributions that can be installed through WSL, run:

wsl --install --online

You may also use:

wsl --list --online

Depending on your Windows/WSL version, the output will show distributions available for installation.

💡 Why use this command?

Instead of guessing distribution names, you can first check the names Windows recognizes.

For example, a distribution may have a specific identifier that should be passed to the installation command.

📥 Step 6 — Install a Linux Distribution

Once you know the distribution name, install it with:

wsl --install -d <distribution-name>

For example:

wsl --install -d Ubuntu

Or, if the available distribution is listed under another identifier:

wsl --install -d kali-linux

⚠️ Administrator privileges

The setup notes recommend running PowerShell as an Administrator for the installation process.

To do that:

Open the Start menu.
Search for PowerShell.
Right-click PowerShell.
Select Run as administrator.
Run the WSL installation command.

🗑️ Step 7 — Uninstall a Distribution

There are two approaches mentioned in the notes.

Method 1 — Windows Settings

You can uninstall a Linux distribution through:

Settings → Apps → Installed apps

Find the distribution you want to remove and uninstall it.

Method 2 — Use the WSL Command

You can unregister a distribution with:

wsl --unregister <distribution-name>

Example:

wsl --unregister Ubuntu

⚠️ Important

wsl --unregister removes the WSL distribution and its associated Linux filesystem/data.

Therefore, do not use this command unless you are sure you want to remove that distribution and its data.

⭐ Step 8 — Change the Default Distribution

If you have multiple Linux distributions installed, you can choose which one launches when you run:

wsl

Use:

wsl --set-default <distribution-name>

For example:

wsl --set-default kali-linux

🧠 How does this work?

Suppose you have:

Ubuntu
kali-linux

If Ubuntu is the default, running:

wsl

opens Ubuntu.

If you change the default:

wsl --set-default kali-linux

then:

wsl

will open Kali Linux instead.

🚀 Step 9 — Launch and Switch Between Linux Distributions

Launch the default distribution

Simply run:

wsl

This launches your default WSL distribution.

Launch a specific distribution

Use:

wsl -d <distribution-name>

Example:

wsl -d Ubuntu

or:

wsl -d kali-linux

💡 Why is this useful?

You can keep multiple distributions installed and launch the one you need without changing the default distribution.

🚪 Step 10 — Exit and Shut Down WSL

Exit the current Linux shell

Inside Linux, run:

exit

This exits the current Linux shell and returns you to the Windows terminal.

💡 The command exits the current shell; it does not necessarily mean every WSL distribution on your system has been shut down.

🛑 Shut down all WSL instances

From Windows, run:

wsl --shutdown

What does it do?

It shuts down all currently running WSL distributions.

This can be useful when:

🔄 You need to restart WSL completely.
🧹 You want to release resources.
🛠️ You are troubleshooting WSL behavior.

🎯 Shut down a specific distribution

Use:

wsl --terminate <distribution-name>

Example:

wsl --terminate Ubuntu

Difference between the two

Command	Purpose
`wsl --shutdown`	Stops all running WSL distributions
`wsl --terminate Ubuntu`	Stops only the specified distribution

📁 Step 11 — Access Windows Drives from Linux

Windows drives are available inside Linux through /mnt.

For example, the Windows C: drive can be accessed as:

/mnt/c

The D: drive can be accessed as:

/mnt/d

You can navigate to a Windows drive with:

cd /mnt/c

Example

cd /mnt/c
ls

This lets you view files and folders on the Windows C: drive from Linux.

🧠 Understanding the Path

Windows:

C:\

WSL/Linux:

/mnt/c

Windows:

D:\

WSL/Linux:

/mnt/d

The drive letter is converted into a Linux-style path under /mnt.

🪟 Step 12 — Use Windows Commands from Linux

One of the most useful WSL features is the ability to execute Windows commands directly from your Linux shell.

The notes demonstrate this by adding .exe to Windows commands.

For example:

ifconfig.exe

or:

ping.exe

The Windows executable is launched from the Linux environment.

🧠 The basic idea

Instead of:

Windows command

you can invoke the Windows executable:

Windows command.exe

This creates a convenient bridge between Linux and Windows.

📝 Step 13 — Run Windows Applications from Linux

WSL can also launch Windows applications.

For example, the notes use Windows Notepad:

notepad.exe document.txt

This launches Notepad and opens the specified file.

Why is this useful?

You can combine:

🐧 Linux command-line tools
🪟 Windows desktop applications

in the same workflow.

For example:

notepad.exe document.txt

allows a Windows GUI application to be launched directly from your Linux terminal.

💻 Step 14 — Use VS Code with WSL

WSL can be integrated with Visual Studio Code.

The notes describe the workflow as:

code demo.py

This allows you to open a file from the Linux environment in VS Code.

Recommended setup

Install Visual Studio Code on Windows.
Install the WSL extension in VS Code.
Open your WSL terminal.
Navigate to your project.
Run:

code demo.py

🧠 Why the WSL extension matters

The WSL integration allows VS Code to work with your Linux environment rather than treating the project as an ordinary Windows-only project.

This is especially useful for software development because you can use Linux tooling while keeping the Windows VS Code interface.

📂 Step 15 — Open the Current Linux Directory in Windows Explorer

From inside your Linux terminal, run:

explorer.exe .

What does `.` mean?

In Linux:

means:

the current directory

Therefore:

explorer.exe .

means:

Open the current Linux directory using Windows Explorer.

Example

cd ~/projects
explorer.exe .

Windows Explorer will open the current location.

🐧 Step 16 — Run Linux Commands from Windows

WSL also works in the opposite direction.

You can execute Linux commands directly from a Windows terminal by prefixing the command with:

wsl

For example:

wsl cat demo.txt

How does it work?

Windows runs:

wsl

and passes the remaining command to the Linux environment.

So:

wsl cat demo.txt

runs the Linux command:

cat demo.txt

without requiring you to manually enter the Linux shell first.

🛠️ Step 17 — Kali Linux Tweaks

If you are using Kali Linux, the notes mention:

kali-tweaks

What is it used for?

kali-tweaks provides a way to configure and customize aspects of a Kali Linux installation.

You can explore the available options from the tool itself.

Run:

kali-tweaks

and follow the interactive menus.

💡 This section is specific to Kali Linux. The command may not be available in other Linux distributions.

🔥 WSL's Windows ↔ Linux Integration

One of the biggest advantages of WSL is that Windows and Linux can work together.

Here is the basic relationship:

You can:

🐧 Linux → Windows

Run Windows commands:

ping.exe

Run Windows applications:

notepad.exe document.txt

Open Windows Explorer:

explorer.exe .

Launch VS Code:

code demo.py

🪟 Windows → Linux

Run Linux commands from Windows:

wsl cat demo.txt

This two-way integration is what makes WSL particularly convenient for development workflows.

🧠 Command Cheat Sheet

⚙️ Installation & Updates

Command	Purpose
`wsl --status`	Show WSL status/configuration information
`wsl --update`	Update WSL
`wsl --install --online`	Show distributions available for installation
`wsl --install -d <distro>`	Install a specific distribution

📦 Distribution Management

Command	Purpose
`wsl --list`	List installed distributions
`wsl --list --running`	List running distributions
`wsl --list --verbose`	Show detailed distribution information
`wsl --set-default <distro>`	Set the default distribution
`wsl --unregister <distro>`	Remove/unregister a distribution

🚀 Starting & Stopping

Command	Purpose
`wsl`	Launch the default distribution
`wsl -d <distro>`	Launch a specific distribution
`exit`	Exit the current Linux shell
`wsl --shutdown`	Shut down all WSL instances
`wsl --terminate <distro>`	Terminate one distribution

🪟 Windows ↔ Linux Integration

Command	Purpose
`cd /mnt/c`	Access the Windows C: drive
`explorer.exe .`	Open the current directory in Windows Explorer
`notepad.exe document.txt`	Open a file in Windows Notepad
`ping.exe`	Run the Windows ping executable from Linux
`code demo.py`	Open a file in VS Code
`wsl cat demo.txt`	Run a Linux command from Windows

🧪 Example: A Simple WSL Development Workflow

Here is a practical example combining several commands from this guide.

1️⃣ Check WSL

From PowerShell:

wsl --status

2️⃣ Update WSL

wsl --update

3️⃣ Check installed distributions

wsl --list --verbose

4️⃣ Start Ubuntu

wsl -d Ubuntu

5️⃣ Navigate to a Windows project directory

cd /mnt/c/Users/<your-username>/Desktop

6️⃣ Create or access your project

cd my-project

7️⃣ Open the project in VS Code

code .

8️⃣ Open the same directory in Windows Explorer

explorer.exe .

This workflow demonstrates how Windows and Linux can work together without constantly switching environments.

🧩 Useful Mental Model

If you are new to WSL, remember these three rules:

Rule 1 — Windows drives live under `/mnt`

C:\  →  /mnt/c
D:\  →  /mnt/d

Rule 2 — Windows `.exe` programs can be launched from Linux

notepad.exe
explorer.exe .

Rule 3 — Linux commands can be launched from Windows using `wsl`

wsl <linux-command>

For example:

wsl cat demo.txt

Once these three concepts become familiar, WSL becomes much easier to understand.

⚠️ Important Notes

🔐 Some WSL installation operations may require an Administrator PowerShell.
🔄 Restart Windows after enabling the required Windows features.
🗑️ Be careful with wsl --unregister because it removes the selected distribution and its data.
🐧 kali-tweaks is intended for Kali Linux.
💻 For VS Code + WSL development, install the WSL extension in VS Code.
📁 Windows drives are commonly accessed through /mnt/<drive-letter> from Linux.
🛑 wsl --shutdown affects all running WSL distributions, while wsl --terminate <distro> targets one distribution.

📖 Official Documentation

For the latest and most authoritative information, always refer to Microsoft's official WSL documentation.

🖥️ WSL GUI Applications

Microsoft's WSL GUI applications guide:

https://learn.microsoft.com/en-us/windows/wsl/tutorials/gui-apps

📚 WSL Basic Commands

Microsoft's WSL basic commands documentation:

https://learn.microsoft.com/en-us/windows/wsl/basic-commands

🔎 WSL is actively maintained, so command behavior and supported features can change over time. The official Microsoft documentation should be treated as the final reference for current behavior.

🎉 Conclusion

WSL provides a powerful bridge between Windows and Linux.

With just a few commands, you can:

🐧 Install and manage Linux distributions.
🔄 Update and troubleshoot WSL.
📦 Run multiple distributions.
🪟 Access Windows files from Linux.
💻 Run Windows applications from Linux.
🐧 Run Linux commands from Windows.
📝 Use VS Code with a Linux development environment.
📂 Open Linux directories directly in Windows Explorer.

The most important commands to remember are:

wsl --status
wsl --update
wsl --list --verbose
wsl --install -d <distribution-name>
wsl --set-default <distribution-name>
wsl
wsl -d <distribution-name>
wsl --shutdown
wsl --terminate <distribution-name>

And from inside Linux:

cd /mnt/c
explorer.exe .
notepad.exe document.txt
code demo.py

Happy Linux-ing on Windows! 🐧💻🚀

Configure Claude Code with Agent Router Using settings.json

Arpan Dhara — Mon, 10 Aug 2026 12:15:13 +0000

If you want to use Agent Router as the API endpoint for Claude Code, you can configure the connection directly through Claude Code's settings.json file.

This configuration sets:

Your Anthropic API key
Agent Router as the API base URL
The Claude model you want to use
Claude Code permission rules

1. Create or open `settings.json`

Depending on your Claude Code setup, create or edit your settings.json configuration file.

The basic configuration looks like this:

{
  "env": {
    "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY",
    "ANTHROPIC_BASE_URL": "https://agentrouter.org",
    "ANTHROPIC_MODEL": "claude-opus-5"
  },
  "permissions": {
    "allow": [],
    "deny": []
  }
}

2. Configure the Anthropic API Key

Replace:

"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY"

with your actual API key.

For example:

"ANTHROPIC_API_KEY": "sk-your-api-key-here"

3. Configure Agent Router

The following setting tells Claude Code to send API requests through Agent Router:

"ANTHROPIC_BASE_URL": "https://agentrouter.org"

Instead of communicating directly with the default Anthropic API endpoint, Claude Code will use the configured base URL.

4. Select the Claude Model

Set the model you want Claude Code to use:

"ANTHROPIC_MODEL": "claude-opus-5"

The model name must match a model supported by your Agent Router configuration.

If your Agent Router account uses a different model identifier, replace the value accordingly.

5. Configure Permissions

The permissions section controls which operations Claude Code is allowed or denied.

The minimal configuration is:

"permissions": {
  "allow": [],
  "deny": []
}

You can later add specific permissions according to your Claude Code workflow.

Complete `settings.json`

Here is the complete configuration:

{
  "env": {
    "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY",
    "ANTHROPIC_BASE_URL": "https://agentrouter.org",
    "ANTHROPIC_MODEL": "claude-opus-5"
  },
  "permissions": {
    "allow": [],
    "deny": []
  }
}

Once the configuration is saved, Claude Code can use the configured Agent Router endpoint and model according to your setup.

Integrating AgentRouter with Tauric Research TradingAgents

Arpan Dhara — Sat, 08 Aug 2026 17:06:56 +0000

If you're using Tauric Research's TradingAgents framework and want to add AgentRouter as a fully supported LLM provider, this guide will walk you through the complete integration.

The process is organized file-by-file, so you can open each file and make all of the required changes before moving to the next one.

TradingAgents Repository:
[https://github.com/TauricResearch/TradingAgents.git]

What We'll Do

In this tutorial, we'll:

Register the AgentRouter API endpoint
Configure the AgentRouter WAF-bypass headers
Add AgentRouter's model catalog
Configure the AgentRouter API key environment variable
Bypass strict model-name validation
Add AgentRouter to the TradingAgents CLI
Configure the .env file
Reinstall and restart TradingAgents

Let's get started.

Step 1 — Update `openai_client.py`

Open:

tradingagents/llm_clients/openai_client.py

This file requires two changes:

Register the AgentRouter API endpoint
Configure the headers required by AgentRouter

The integration guide specifically places both changes in this file.

1A — Register the AgentRouter API Endpoint

Locate the:

OPENAI_COMPATIBLE_PROVIDERS

dictionary.

Add AgentRouter alongside the existing OpenAI-compatible providers:

"openrouter": ProviderSpec(
    base_url="https://openrouter.ai/api/v1"
),
"agentrouter": ProviderSpec(
    base_url="https://agentrouter.org/v1"
),

The important part here is the AgentRouter base URL:

https://agentrouter.org/v1

This allows TradingAgents to communicate with AgentRouter through its OpenAI-compatible API interface.

1B — Configure AgentRouter WAF-Bypass Headers

Still in:

tradingagents/llm_clients/openai_client.py

Locate the get_llm(self) method inside the OpenAIClient class.

Find the section that forwards user-provided keyword arguments:

# Forward user-provided kwargs
for key in _PASSTHROUGH_KWARGS:
    if key not in self.kwargs:
        continue
    if key == "reasoning_effort" and not _supports_reasoning_effort(self.model):
        continue
    llm_kwargs[key] = self.kwargs[key]

Immediately after this section, add the AgentRouter-specific headers:

# Forward user-provided kwargs
for key in _PASSTHROUGH_KWARGS:
    if key not in self.kwargs:
        continue
    if key == "reasoning_effort" and not _supports_reasoning_effort(self.model):
        continue
    llm_kwargs[key] = self.kwargs[key]

# --- NEW CODE START: Add spoofed headers for AgentRouter ---
if self.provider == "agentrouter":
    llm_kwargs["default_headers"] = {
        "Originator": "codex_cli_rs",
        "User-Agent": "codex_cli_rs/0.114.0 (Windows 10.0.26100; x86_64)",
        "Version": "0.114.0",
    }

# --- NEW CODE END ---

# The subclass (provider quirks) comes from the registry spec.
return chat_cls(**llm_kwargs)

These headers are part of the AgentRouter integration described in the guide.

Important: Make sure this code is placed inside the get_llm(self) method and before the final return chat_cls(**llm_kwargs).

Step 2 — Update `model_catalog.py`

Now open:

tradingagents/llm_clients/model_catalog.py

This file controls the models that can be selected for each provider.

2A — Define AgentRouter Models

Near the top of the file, around the existing model definitions, add:

_AGENTROUTER_MODELS: dict[str, list[ModelOption]] = {
    "quick": [
        ("GPT-4o Mini", "openai/gpt-4o-mini"),
        ("Claude 3.5 Haiku", "anthropic/claude-3-haiku"),
        ("DeepSeek V3", "deepseek/deepseek-chat"),
        ("Custom model ID", "custom"),
    ],
    "deep": [
        ("GPT-4o", "openai/gpt-4o"),
        ("Claude 3.5 Sonnet", "anthropic/claude-3-5-sonnet"),
        ("DeepSeek R1", "deepseek/deepseek-reasoner"),
        ("Custom model ID", "custom"),
    ],
}

The quick category contains lighter model choices, while deep contains the deeper/reasoning-oriented choices listed in the integration guide.

2B — Register the AgentRouter Model Catalog

Scroll down to:

MODEL_OPTIONS

Add the AgentRouter mapping:

"bedrock": _CUSTOM_ONLY,
"agentrouter": _AGENTROUTER_MODELS,

This connects the agentrouter provider with the model catalog you just created.

Step 3 — Update `api_key_env.py`

Open:

tradingagents/llm_clients/api_key_env.py

Locate:

PROVIDER_API_KEY_ENV

Add the AgentRouter environment variable:

"openrouter": "OPENROUTER_API_KEY",
"agentrouter": "AGENTROUTER_API_KEY",

This tells TradingAgents to retrieve the AgentRouter API key from:

AGENTROUTER_API_KEY

The integration guide specifies this exact provider-to-environment-variable mapping.

Step 4 — Update `validators.py`

Open:

tradingagents/llm_clients/validators.py

TradingAgents normally performs strict validation of model names.

For AgentRouter, add the provider to:

_ANY_MODEL_PROVIDERS

The resulting tuple should include agentrouter:

_ANY_MODEL_PROVIDERS = (
    "ollama",
    "openrouter",
    "openai_compatible",
    "mistral",
    "kimi",
    "groq",
    "nvidia",
    "bedrock",
    "agentrouter",
)

This allows AgentRouter to work with model IDs without being restricted by the strict model-name validation.

Step 5 — Update `cli/utils.py`

Now open:

cli/utils.py

Locate:

_llm_provider_table()

This function contains the providers displayed in the interactive TradingAgents CLI.

Find the OpenRouter entry and add AgentRouter immediately after it:

("OpenRouter", "openrouter", "https://openrouter.ai/api/v1"),
("AgentRouter", "agentrouter", "https://agentrouter.org/v1"),

After this change, AgentRouter should appear as a selectable provider when you launch the TradingAgents CLI.

Step 6 — Configure the `.env` File

Now open the .env file in the root directory of your TradingAgents project.

Add your AgentRouter API key:

AGENTROUTER_API_KEY=your_actual_agentrouter_key_here

Replace:

your_actual_agentrouter_key_here

with your actual AgentRouter API key.

Keep Your API Key Private

Do not commit your .env file or API key to GitHub.

Make sure your .gitignore contains:

.env

Step 7 — Reinstall and Restart TradingAgents

Once you've completed all of the modifications, save your files.

Open your VS Code terminal and run:

pip install -e .

This reinstalls the package in editable mode so the modified Python definitions are refreshed.

Then launch TradingAgents:

TradingAgents

The integration guide specifically recommends restarting the CLI session after making the code changes so Python loads the modified code from disk.

Complete File Checklist

At this point, you should have modified the following files:

tradingagents/
├── llm_clients/
│   ├── openai_client.py
│   ├── model_catalog.py
│   ├── api_key_env.py
│   └── validators.py
│
└── cli/
    └── utils.py

.env

Here's a quick summary of what changes in each file:

openai_client.py
    ├── AgentRouter API endpoint
    └── AgentRouter WAF-bypass headers

model_catalog.py
    └── AgentRouter model definitions

api_key_env.py
    └── AGENTROUTER_API_KEY mapping

validators.py
    └── AgentRouter model validation bypass

cli/utils.py
    └── AgentRouter CLI provider entry

.env
    └── Your AgentRouter API key

Quick Verification Checklist

Before launching TradingAgents, verify that you have completed every step:

[ ] Added the AgentRouter API endpoint
[ ] Added the AgentRouter headers inside get_llm()
[ ] Added _AGENTROUTER_MODELS
[ ] Added "agentrouter" to MODEL_OPTIONS
[ ] Added AGENTROUTER_API_KEY to PROVIDER_API_KEY_ENV
[ ] Added "agentrouter" to _ANY_MODEL_PROVIDERS
[ ] Added AgentRouter to the CLI provider table
[ ] Added your AgentRouter API key to .env
[ ] Ran pip install -e .
[ ] Restarted the TradingAgents CLI

Conclusion

That's it!

AgentRouter is now registered as a provider in the TradingAgents framework, with:

OpenAI-compatible API support
AgentRouter-specific headers
Predefined model selections
Custom model support
Environment-based API key configuration
CLI provider selection

You can now launch TradingAgents and select AgentRouter from the interactive provider menu.

TradingAgents Repository:
[YOUR_TRADINGAGENTS_REPOSITORY_LINK]

If you're integrating another OpenAI-compatible provider into TradingAgents, the same general architecture can be useful: provider registration, model catalog configuration, API-key mapping, validation rules, and CLI registration.

Final Integration Flow

AgentRouter
     │
     ▼
API Endpoint Registration
     │
     ▼
OpenAIClient
     │
     ├── AgentRouter Headers
     │
     ▼
Model Catalog
     │
     ▼
API Key Environment Variable
     │
     ▼
Model Validation
     │
     ▼
TradingAgents CLI
     │
     ▼
AgentRouter LLM

Happy trading! 🚀

Integrating TokenRouter with Tauric Research TradingAgents

Arpan Dhara — Sat, 08 Aug 2026 17:02:48 +0000

If you're using Tauric Research's TradingAgents framework and want to integrate TokenRouter as an LLM provider, this guide walks through the complete process step by step.

The integration adds TokenRouter support to the TradingAgents interactive CLI and provides a predefined list of models that you can select directly from the interface.

TradingAgents Repository:
[https://github.com/TauricResearch/TradingAgents.git]

What We'll Do

In this tutorial, we'll:

Define TokenRouter models in the model catalog
Register the TokenRouter API endpoint
Configure the TokenRouter API key
Bypass strict model-name validation
Add TokenRouter to the interactive CLI
Configure the .env file
Reinstall and restart TradingAgents

Let's get started.

Step 1 — Define TokenRouter Models in the Model Catalog

First, open:

tradingagents/llm_clients/model_catalog.py

Near the top of the file, around the model definitions section, add a TokenRouter model dictionary.

_TOKENROUTER_MODELS: dict[str, list[ModelOption]] = {
    "quick": [
        ("GPT-4o Mini", "openai/gpt-4o-mini"),
        ("Claude 3.5 Haiku", "anthropic/claude-3-haiku"),
        ("DeepSeek V3", "deepseek/deepseek-chat"),
        ("Custom model ID", "custom"),
    ],
    "deep": [
        ("GPT-4o", "openai/gpt-4o"),
        ("Claude 3.5 Sonnet", "anthropic/claude-3-5-sonnet"),
        ("DeepSeek R1", "deepseek/deepseek-reasoner"),
        ("Custom model ID", "custom"),
    ],
}

The quick and deep categories provide predefined model choices.

You can also use the custom option when you want to specify your own model ID.

Next, locate MODEL_OPTIONS, around the section where providers are mapped.

Add tokenrouter after bedrock:

"bedrock": _CUSTOM_ONLY,
"tokenrouter": _TOKENROUTER_MODELS,

After this change, TradingAgents will know which models should be presented when TokenRouter is selected.

Step 2 — Register the TokenRouter API Endpoint

Now we need to tell TradingAgents where the TokenRouter API is located.

Open:

tradingagents/llm_clients/openai_client.py

Find:

OPENAI_COMPATIBLE_PROVIDERS

Add TokenRouter to the provider definitions:

"openrouter": ProviderSpec(
    base_url="https://openrouter.ai/api/v1"
),
"tokenrouter": ProviderSpec(
    base_url="https://api.tokenrouter.com/v1"
),

TokenRouter is registered here as an OpenAI-compatible provider.

Step 3 — Configure the TokenRouter API Key Environment Variable

Next, open:

tradingagents/llm_clients/api_key_env.py

Find:

PROVIDER_API_KEY_ENV

Add the TokenRouter environment variable:

"openrouter": "OPENROUTER_API_KEY",
"tokenrouter": "TOKENROUTER_API_KEY",

This tells TradingAgents which environment variable contains the TokenRouter API key.

Step 4 — Bypass Strict Model Name Validation

TradingAgents may normally validate model names against its predefined rules.

Because TokenRouter can provide different models through its API, we need to add it to the providers that allow arbitrary model names.

Open:

tradingagents/llm_clients/validators.py

Locate:

_ANY_MODEL_PROVIDERS

Then add tokenrouter:

_ANY_MODEL_PROVIDERS = (
    "ollama",
    "openrouter",
    "openai_compatible",
    "mistral",
    "kimi",
    "groq",
    "nvidia",
    "bedrock",
    "tokenrouter",
)

This allows TokenRouter model IDs to pass through the model validation layer.

Step 5 — Add TokenRouter to the Interactive CLI

Now we'll make TokenRouter visible in the TradingAgents interactive CLI.

Open:

cli/utils.py

Locate:

_llm_provider_table()

Find the OpenRouter entry and add TokenRouter immediately after it:

("OpenRouter", "openrouter", "https://openrouter.ai/api/v1"),
("TokenRouter", "tokenrouter", "https://api.tokenrouter.com/v1"),

After this change, TokenRouter should appear as a selectable provider when you launch the TradingAgents CLI.

Step 6 — Add Your TokenRouter API Key

Now we need to provide your TokenRouter API key.

Open the .env file in the root directory of the TradingAgents project.

Add:

TOKENROUTER_API_KEY=your_actual_tokenrouter_key_here

Replace:

your_actual_tokenrouter_key_here

with your actual TokenRouter API key.

Important: Never commit your .env file or API key to GitHub.

Make sure .env is included in your .gitignore.

Step 7 — Reinstall and Restart TradingAgents

After making all of the changes, save your files.

Open the VS Code terminal and reinstall the project in editable mode:

pip install -e .

Then launch TradingAgents:

TradingAgents

Restarting the application is important because Python needs to load the modified definitions from disk.

Final Project Changes

After completing the integration, you should have modified the following files:

tradingagents/
├── llm_clients/
│   ├── model_catalog.py
│   ├── openai_client.py
│   ├── api_key_env.py
│   └── validators.py
│
└── cli/
    └── utils.py

.env

The main additions are:

TokenRouter model definitions
        ↓
TokenRouter API endpoint
        ↓
TOKENROUTER_API_KEY environment variable
        ↓
Model validation bypass
        ↓
TokenRouter CLI provider
        ↓
TradingAgents

That's It!

TokenRouter is now integrated into the TradingAgents framework as an LLM provider.

You should now be able to select TokenRouter from the interactive CLI and use the predefined models or provide a custom model ID.

If you're working with the Tauric Research TradingAgents project, you can find the repository here:

Repository:
[YOUR_TRADINGAGENTS_REPOSITORY_LINK]

Quick Checklist

Before running TradingAgents, make sure you've completed everything:

[ ] Added _TOKENROUTER_MODELS
[ ] Added "tokenrouter" to MODEL_OPTIONS
[ ] Added the TokenRouter API endpoint
[ ] Added TOKENROUTER_API_KEY
[ ] Added TokenRouter to _ANY_MODEL_PROVIDERS
[ ] Added TokenRouter to the CLI provider table
[ ] Added your API key to .env
[ ] Ran pip install -e .
[ ] Restarted TradingAgents

If all of the above are complete, you should be ready to use TokenRouter with TradingAgents.

This integration guide is based on the TokenRouter integration procedure for the TradingAgents framework.

DEV Community: Arpan Dhara

🐧 WSL (Windows Subsystem for Linux) — Complete Setup & Command Guide

📚 Table of Contents

🐧 What is WSL?

⚙️ Step 1 — Enable WSL Features

1. Open Windows Features

💡 Why are these features required?

🔍 Step 2 — Check Your WSL Installation

What does it do?

Example

🔄 Step 3 — Update WSL

What does it do?

Recommended workflow

📦 Step 4 — List Installed Linux Distributions

What does it do?

🟢 Show Currently Running Distributions

What does it do?

🔎 Show Detailed Distribution Information

What does it show?

🌐 Step 5 — See Available Distributions

💡 Why use this command?

📥 Step 6 — Install a Linux Distribution

⚠️ Administrator privileges

🗑️ Step 7 — Uninstall a Distribution

Method 1 — Windows Settings

Method 2 — Use the WSL Command

⚠️ Important

⭐ Step 8 — Change the Default Distribution

🧠 How does this work?

🚀 Step 9 — Launch and Switch Between Linux Distributions

Launch the default distribution

Launch a specific distribution

💡 Why is this useful?

🚪 Step 10 — Exit and Shut Down WSL

Exit the current Linux shell

🛑 Shut down all WSL instances

What does it do?

🎯 Shut down a specific distribution

Difference between the two

📁 Step 11 — Access Windows Drives from Linux

Example

🧠 Understanding the Path

🪟 Step 12 — Use Windows Commands from Linux

🧠 The basic idea

📝 Step 13 — Run Windows Applications from Linux

Why is this useful?

💻 Step 14 — Use VS Code with WSL

Recommended setup

🧠 Why the WSL extension matters

📂 Step 15 — Open the Current Linux Directory in Windows Explorer

What does . mean?

Example

🐧 Step 16 — Run Linux Commands from Windows

How does it work?

🛠️ Step 17 — Kali Linux Tweaks

What is it used for?

🔥 WSL's Windows ↔ Linux Integration

🐧 Linux → Windows

🪟 Windows → Linux

🧠 Command Cheat Sheet

⚙️ Installation & Updates

📦 Distribution Management

🚀 Starting & Stopping

🪟 Windows ↔ Linux Integration

🧪 Example: A Simple WSL Development Workflow

1️⃣ Check WSL

2️⃣ Update WSL

3️⃣ Check installed distributions

4️⃣ Start Ubuntu

5️⃣ Navigate to a Windows project directory

6️⃣ Create or access your project

7️⃣ Open the project in VS Code

8️⃣ Open the same directory in Windows Explorer

🧩 Useful Mental Model

Rule 1 — Windows drives live under /mnt

Rule 2 — Windows .exe programs can be launched from Linux

Rule 3 — Linux commands can be launched from Windows using wsl

⚠️ Important Notes

📖 Official Documentation

🖥️ WSL GUI Applications

What does `.` mean?

Rule 1 — Windows drives live under `/mnt`

Rule 2 — Windows `.exe` programs can be launched from Linux

Rule 3 — Linux commands can be launched from Windows using `wsl`

1. Create or open `settings.json`

Complete `settings.json`

Step 1 — Update `openai_client.py`

Step 2 — Update `model_catalog.py`

Step 3 — Update `api_key_env.py`

Step 4 — Update `validators.py`

Step 5 — Update `cli/utils.py`

Step 6 — Configure the `.env` File