Stop Juggling CLI Windows! Codexia Unites Codex + Claude in One Insane Workspace

You're staring at six terminal tabs. Codex CLI is churning through a refactor in one window. Claude Code is debugging an API issue in another. Your editor sits in a third. Somewhere, a git worktree you forgot about holds half-finished changes. And you just realized the prompt you crafted so carefully? Gone. Lost to shell history, buried under a thousand ls commands.

Sound familiar? This is the silent productivity killer that AI-native developers refuse to talk about. We've solved the coding part with brilliant agents—but we've made the workflow part worse than ever.

What if you could collapse this chaos into a single, elegant command center? What if your agents didn't just run—they lived in a workspace designed for them?

Enter Codexia: the Tauri v2 application that fuses Codex CLI and Claude Code into one breathtaking agent workstation. Task scheduling, git worktree management, remote control via headless server, and a prompt notepad that actually persists. This isn't another wrapper. This is how AI coding was supposed to feel.

Ready to reclaim your sanity? Let's tear this thing apart and see what makes it tick.

What is Codexia?

Codexia is a Tauri v2 desktop application built by developer milisp that transforms fragmented AI coding workflows into a unified, extensible workspace. Born from the friction of managing multiple CLI agents simultaneously, it combines an IDE-like editor, headless web server, prompt notepad, and task automation into one cohesive environment.

The project sits at a fascinating intersection. OpenAI's Codex CLI and Anthropic's Claude Code represent the two most powerful coding agents available today. Yet using them together has historically meant context-switching hell—different terminals, different histories, different mental models. Codexia eliminates this friction entirely.

Why is it trending now? Three forces converged:

• The agent explosion: 2024-2025 saw coding agents mature from demos to daily drivers. Developers need orchestration layers.
• The MCP protocol: Model Context Protocol standardization created demand for unified skill marketplaces.
• The local-first backlash: After cloud AI fatigue, developers crave tools that keep data on-machine with optional remote access.

Codexia answers all three. Its dual-license model (AGPL-3.0 for open source, commercial for SaaS) also signals serious intent—this isn't a weekend project, it's infrastructure.

The architecture reveals the ambition: React + TypeScript + Zustand frontend, Rust-powered Tauri backend, Axum web server for headless operation, and WebSocket streams for real-time browser clients. This is systems engineering, not scripting.

Key Features That Will Blow Your Mind

Codexia isn't a feature list—it's a philosophy of agent-centric development. Here's what separates it from duct-taped alternatives:

Agent Workflows with Task Scheduling

Recurring automation without cron jobs or CI complexity. Schedule code reviews, documentation generation, or test runs on intervals. The scheduler integrates directly with both Codex and Claude agents, maintaining session state across executions.

Git Worktree Management

Finally, a visual interface for git worktrees! Switch between feature branches without cd gymnastics or stash confusion. The file tree updates instantly as you hop contexts—critical when agents modify code across multiple branches.

Headless Web Server with Remote Control

Run Codexia on a server, control it from anywhere. The Axum-powered web server exposes full API access with WebSocket real-time updates. Your workstation becomes your cloud—without the cloud's privacy compromises.

IDE-Like Editor + Prompt Notepad

Stop losing prompts to shell history. The dedicated notepad saves, categorizes, and revises your agent instructions. Pair it with the Monaco-based editor for human-in-the-loop refinement of agent output.

One-Click Data Preview

PDF, XLSX, CSV files render instantly—no external applications needed. Essential when agents generate reports or analyze datasets.

MCP Server & Skills Marketplaces

Discover and install Model Context Protocol servers and agent skills from curated marketplaces. Extend capabilities without touching configuration files.

Usage Analytics Dashboard

Track token consumption, session frequency, and agent performance. Optimize costs and identify which workflows deliver ROI.

Deep Personalization

Theme engine with accent customization. Make it yours—because you'll spend hours here.

Use Cases Where Codexia Absolutely Dominates

1. Multi-Agent Code Review Pipelines

Schedule Codex to perform security audits every morning at 6 AM, while Claude handles architecture reviews on demand. Results aggregate in one dashboard. No more email chains or Slack bots.

2. Distributed Team Agent Orchestration

Deploy Codexia headless on a secure server. Junior developers trigger complex refactoring agents through the web API without installing CLIs. Senior engineers monitor via WebSocket streams.

3. Long-Running Research Tasks

Need Claude to analyze a 50-file codebase overnight? The task scheduler ensures completion, with git worktree isolation preventing branch pollution. Check results in the morning—no terminal left running.

4. Prompt Engineering at Scale

Iterate on system prompts using the notepad's versioning. A/B test against Codex vs. Claude. Track which variants produce mergeable code via the analytics dashboard.

5. Compliance-Sensitive Environments

Financial and healthcare developers love the local-first architecture. No data leaves the machine unless you explicitly configure remote access. Process isolation prevents agent escape.

Step-by-Step Installation & Setup Guide

Prerequisites

Before installing Codexia, ensure you have the required agent CLIs:

# Install Codex CLI (OpenAI)
npm install -g @openai/codex

# Install Claude Code (Anthropic)
npm install -g @anthropic-ai/claude-code

Verify installations:

codex --version
claude --version

macOS Installation (Homebrew)

The fastest path to productivity:

# Add the custom tap
brew tap milisp/codexia

# Install the cask
brew install --cask codexia

Prebuilt Binaries (All Platforms)

For macOS, Linux, or Windows:

1. Visit GitHub Releases
2. Download the appropriate asset for your platform
3. Alternative mirror: Modern GitHub Release

Launch and Configure

# macOS: Launch from Applications, or via terminal
open /Applications/Codexia.app

# Linux: Execute the AppImage or extracted binary
./codexia-x86_64.AppImage

# Windows: Run the MSI installer, then launch from Start Menu

First-run setup:

1. Add project directory: Click "New Workspace" and select your repository root
2. Configure agent paths: Codexia auto-detects Codex and Claude CLIs; verify in Settings → Agents
3. Initialize git worktree support: Settings → Git → Enable worktree visualization
4. Optional: Start headless server: Settings → Server → Enable on port 3000

Environment Configuration

For headless server operation, set these environment variables:

export CODEXIA_SERVER_PORT=3000
export CODEXIA_SERVER_HOST=0.0.0.0
export CODEXIA_WS_PATH=/ws

Create a systemd service for persistent headless operation:

# /etc/systemd/system/codexia.service
[Unit]
Description=Codexia Headless Agent Server
After=network.target

[Service]
Type=simple
User=codexia
Environment="CODEXIA_SERVER_PORT=3000"
ExecStart=/usr/local/bin/codexia --headless
Restart=always

[Install]
WantedBy=multi-user.target

REAL Code Examples from the Repository

Let's examine actual implementation patterns from Codexia's architecture. These aren't toy examples—they're production-grade patterns you can adapt.

Example 1: Desktop Command Registration (Tauri Rust Backend)

From src-tauri/src/lib.rs, the core desktop entry point:

// src-tauri/src/lib.rs
// Core desktop commands and state management

use tauri::Manager;
use std::sync::Arc;
use tokio::sync::Mutex;

/// Application state shared across commands
pub struct AppState {
    // Holds active agent sessions for Codex and Claude
    pub sessions: Arc<Mutex<SessionStore>>,
    // Git worktree registry for project isolation
    pub worktrees: Arc<Mutex<WorktreeManager>>,
    // Task scheduler for recurring automation
    pub scheduler: Arc<Mutex<TaskScheduler>>,
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        // Initialize shared state accessible to all commands
        .manage(AppState {
            sessions: Arc::new(Mutex::new(SessionStore::new())),
            worktrees: Arc::new(Mutex::new(WorktreeManager::new())),
            scheduler: Arc::new(Mutex::new(TaskScheduler::new())),
        })
        // Register all IPC commands available to frontend
        .invoke_handler(tauri::generate_handler![
            commands::create_agent_session,
            commands::send_agent_turn,
            commands::list_worktrees,
            commands::schedule_task,
            commands::cancel_task,
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

What's happening here? The AppState struct uses Arc<Mutex<_>> for thread-safe shared state across async Tauri commands. This pattern is crucial—multiple frontend invocations may access agent sessions simultaneously. The mobile_entry_point conditional compilation shows Codexia's cross-platform ambitions.

Example 2: Headless Server Startup (Axum Web Server)

From src-tauri/src/web/server.rs:

// src-tauri/src/web/server.rs
// Headless server startup for remote control

use axum::{Router, Server};
use std::net::SocketAddr;
use tower_http::cors::CorsLayer;

/// Starts the headless web server on configured port
pub async fn start_server(state: AppState) -> Result<(), Box<dyn std::error::Error>> {
    // Build router with all API routes and shared state
    let app = Router::new()
        // Merge modular route handlers
        .merge(routes::codex_routes())
        .merge(routes::claude_routes())
        .merge(routes::automation_routes())
        .merge(routes::filesystem_routes())
        .merge(routes::git_routes())
        // Inject shared application state for handler access
        .with_state(state)
        // Enable CORS for browser client access
        .layer(CorsLayer::permissive());

    // Bind to configured address (default 0.0.0.0:3000)
    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    
    println!("Codexia headless server listening on {}", addr);
    
    // Start server with graceful shutdown support
    Server::bind(&addr)
        .serve(app.into_make_service())
        .await?;
    
    Ok(())
}

The power move: This server runs inside the Tauri application, not as a separate process. That means desktop users get local-first operation, but the same binary can run --headless on servers. The CorsLayer::permissive() is development-friendly; production deployments should restrict origins.

Example 3: WebSocket Broadcast Stream for Real-Time Updates

From the architecture documentation, the WebSocket implementation:

// WebSocket broadcast stream at /ws for browser clients
use axum::{
    extract::ws::{WebSocket, WebSocketUpgrade},
    response::Response,
};
use tokio::sync::broadcast;

/// Channel for broadcasting agent events to all connected clients
type BroadcastTx = broadcast::Sender<AgentEvent>;

/// Handler that upgrades HTTP connections to WebSocket
pub async fn ws_handler(
    ws: WebSocketUpgrade,
    // Shared broadcast channel injected via state
    State(tx): State<BroadcastTx>,
) -> Response {
    ws.on_upgrade(move |socket| handle_socket(socket, tx))
}

async fn handle_socket(mut socket: WebSocket, tx: BroadcastTx) {
    // Subscribe to broadcast channel
    let mut rx = tx.subscribe();
    
    loop {
        // Receive events from broadcast channel
        match rx.recv().await {
            Ok(event) => {
                // Serialize and send to this specific client
                let msg = serde_json::to_string(&event).unwrap();
                if socket.send(msg.into()).await.is_err() {
                    break; // Client disconnected
                }
            }
            Err(_) => break, // Channel closed
        }
    }
}

Why this matters: The broadcast::Sender pattern enables one-to-many real-time updates. When an agent completes a turn, all connected browser clients receive the update instantly. This is how you build collaborative agent monitoring without polling.

Example 4: Frontend Tauri Invoke Layer

From src/services/tauri/, how the React frontend calls Rust commands:

// src/services/tauri/agentService.ts
// Frontend invoke layer for agent operations

import { invoke } from '@tauri-apps/api/core';

interface CreateSessionRequest {
  agent: 'codex' | 'claude';
  projectPath: string;
  model?: string;
  systemPrompt?: string;
}

interface TurnRequest {
  sessionId: string;
  prompt: string;
  // Enable automatic approval for non-destructive operations
  autoApprove?: boolean;
}

/**
 * Creates a new agent session with specified configuration
 * Maps to Rust command: commands::create_agent_session
 */
export async function createAgentSession(
  req: CreateSessionRequest
): Promise<string> {
  // Type-safe IPC call to Tauri backend
  const sessionId = await invoke<string>('create_agent_session', {
    agent: req.agent,
    projectPath: req.projectPath,
    model: req.model,
    systemPrompt: req.systemPrompt,
  });
  return sessionId;
}

/**
 * Sends a turn to an existing session, streaming responses
 * via WebSocket after initial acknowledgment
 */
export async function sendAgentTurn(
  req: TurnRequest
): Promise<void> {
  await invoke('send_agent_turn', {
    sessionId: req.sessionId,
    prompt: req.prompt,
    autoApprove: req.autoApprove ?? false,
  });
}

The type safety win: TypeScript interfaces mirror Rust structs. The invoke function is generic over return types. This isn't raw JSON-RPC—it's fully typed cross-language communication. The autoApprove parameter with default shows thoughtful UX design for agent safety.

Example 5: API Route Registration Pattern

From src-tauri/src/web/router.rs:

// src-tauri/src/web/router.rs
// HTTP API route surface

use axum::{
    routing::{get, post, put, delete},
    Router,
};

/// Composes all API routes into unified router
pub fn create_router(state: AppState) -> Router {
    Router::new()
        // Health and real-time endpoints
        .route("/health", get(handlers::health_check))
        .route("/ws", get(handlers::ws_handler))
        
        // Codex lifecycle management
        .route("/api/codex/thread", post(handlers::create_thread))
        .route("/api/codex/thread/:id", get(handlers::get_thread))
        .route("/api/codex/turn", post(handlers::create_turn))
        .route("/api/codex/turn/:id", get(handlers::get_turn))
        .route("/api/codex/model", get(handlers::list_models))
        .route("/api/codex/approval/:id", post(handlers::set_approval))
        
        // Automation scheduler CRUD
        .route("/api/automation", get(handlers::list_tasks))
        .route("/api/automation", post(handlers::create_task))
        .route("/api/automation/:id", put(handlers::update_task))
        .route("/api/automation/:id/run", post(handlers::run_task))
        .route("/api/automation/:id/pause", post(handlers::pause_task))
        .route("/api/automation/:id", delete(handlers::delete_task))
        
        // File system, git, terminal access
        .route("/api/filesystem/*path", get(handlers::read_file))
        .route("/api/git/worktrees", get(handlers::list_worktrees))
        .route("/api/terminal", post(handlers::execute_command))
        
        // Claude Code integration
        .route("/api/cc/session", post(handlers::create_claude_session))
        
        // Productivity features
        .route("/api/notes", get(handlers::list_notes).post(handlers::create_note))
        .route("/api/codex/usage/token", get(handlers::get_token_usage))
        
        .with_state(state)
}

RESTful design insight: The route structure mirrors resource hierarchies. Notice how automation gets full CRUD plus lifecycle operations (run, pause). The wildcard *path for filesystem enables arbitrary file access. This is an API designed for power users, not demo apps.

Advanced Usage & Best Practices

Optimize Agent Session Lifecycle

Don't create sessions per prompt—reuse them. Codexia's SessionStore maintains context. For long-running tasks, schedule with the automation API rather than keeping interactive sessions alive.

Git Worktree Strategy for Parallel Agents

Assign each agent its own worktree branch. Codex works on feature/auth-refactor while Claude explores spike/performance. Merge through the visual worktree manager when ready.

Headless Server Security Hardening

# Run behind reverse proxy with TLS
caddy reverse-proxy --from codexia.yourdomain.com --to localhost:3000

# Restrict CORS origins in production
# Modify src-tauri/src/web/server.rs: CorsLayer::new()
#   .allow_origin("https://codexia.yourdomain.com")

Custom Skill Development

Extend via the MCP marketplace or build private skills. Skills are JSON-configured prompt templates with parameter substitution. Store organization-specific patterns (coding standards, review checklists) as reusable skills.

Telemetry Decision

Telemetry is opt-in, off by default. Enable usage analytics only if you want dashboard insights. The local-first promise means your code never leaves your machine for "training purposes."

Comparison with Alternatives

The verdict: Raw terminals offer maximum flexibility but zero integration. VS Code extensions add polish but can't unify disparate agents. Web IDEs sacrifice local control. Codexia occupies the unique position of local-first, agent-native, extensible workspace.

FAQ

Is Codexia free to use?

Yes! The core application is AGPL-3.0 licensed. Commercial licenses are available for closed-source or SaaS deployments. See COMMERCIAL.md.

Do I need both Codex CLI and Claude Code installed?

Codexia works with either or both. Install the agents you want to use; the UI adapts dynamically.

Can I run Codexia on a server without GUI?

Absolutely. The --headless flag starts only the Axum web server. Access the full feature set via API or browser at http://your-server:3000.

How does process isolation work?

Each agent spawns in a separate OS process with configurable filesystem and network permissions. A compromised agent cannot access other agents' data or your full filesystem without explicit approval.

Is my code sent to external servers?

No. All processing happens locally through your installed Codex/Claude CLIs. The headless server runs on your infrastructure. Opt-in telemetry only sends usage statistics, never code content.

Can I contribute custom API handlers?

Yes! Add handlers in src-tauri/src/web/handlers/, register routes in router.rs, and add frontend invocations in src/services/tauri/. See CONTRIBUTING.md.

What about Windows support?

Prebuilt releases include Windows binaries. Some file system operations may have platform-specific behavior—report issues on GitHub.

Conclusion

Codexia isn't just another tool in the AI coding gold rush. It's a fundamental reimagining of how developers interact with intelligent agents. By unifying Codex CLI and Claude Code in a local-first, extensible workspace, it solves the orchestration problem that everyone felt but nobody fixed.

The Tauri + Rust + React stack delivers native performance with web flexibility. The headless server mode transforms a desktop app into infrastructure. The task scheduler, git worktree management, and prompt notepad address real pain points—not imagined ones.

After weeks of fragmented terminal juggling, switching to Codexia feels like upgrading from a flip phone to a smartphone. The agents were always capable. Finally, the workspace matches their potential.

Your move: Install via brew install --cask codexia, grab a release from GitHub, or dive into the source at github.com/milisp/codexia. Join the Discord and shape the future of agent-native development.

The CLI window juggling stops now. Your agents deserve a home.