Let’s be honest: our browser tab habits are out of control. If you’re anything like me, your workspace is a chaotic graveyard of StackOverflow threads, AWS console tabs, GitHub PRs, and at least four different AI chat interfaces. We’ve got a tab for ChatGPT, another for Claude, maybe a local Ollama instance running in a terminal, and perhaps a Copilot chat pane hogging valuable screen real estate in our IDE.
This fragmented workflow is exhausting. Context switching is the ultimate developer productivity killer. We want the power of autonomous AI agents and LLMs, but we want them integrated seamlessly into our existing workflows—whether we are hacking away on a laptop, monitoring a production server via SSH on a remote terminal, or quickly reviewing a bug report on our phone during our morning commute.
Enter Paseo, a beautiful, open-source coding agent interface that recently took the top spot on Hacker News. Unlike the sea of wrapper startups trying to lock you into their proprietary cloud platforms, Paseo is taking a radically different approach: local-first, open-source, and natively multi-client (supporting Desktop, Mobile, and CLI).
Today, we’re going to dive deep into what Paseo is, why its architecture is a breath of fresh air for developers, and how you can spin it up to orchestrate your local and cloud-based AI workflows.
The Problem with Modern AI Interfaces
Most AI chat interfaces we use today are built for general consumers, not software engineers. They suffer from three core architectural limitations that hamper developer workflows:
- The Browser Sandbox: Web-based UIs cannot easily interact with your local file system, run terminal commands, or inspect your local git repository without complex browser extensions or heavy, insecure local daemon processes.
- Lack of Real-time CLI Integration: As developers, the terminal is our home. Having to copy-paste code snippets from a web browser into a terminal, run them, copy the error output, and paste it back into the browser is an incredibly clunky feedback loop.
- Privacy and Vendor Lock-in: Many developer-focused AI tools require sending your entire codebase to third-party servers. For enterprise devs or anyone working on proprietary code, this is a non-starter. We need a tool that lets us swap out models—from Claude 3.5 Sonnet to a fully local Llama 3 run via Ollama—without changing our UI.
Paseo solves this by acting as a unified, highly polished client layer that talks to your choice of LLM backends while offering a native experience across desktop, mobile, and the command line.
The Paseo Architecture: How It Works
At its core, Paseo is designed around a decoupled client-server architecture. It doesn't force you into a specific LLM provider. Instead, it acts as a highly customizable orchestrator. Here is a simplified mental model of how Paseo structures its operations:
+-------------------------------------------------------------+
| PASEO CLIENT |
| (Desktop Electron/Tauri | Mobile App | Rich CLI) |
+-------------------------------------------------------------+
|
| Secure local IPC / WebSockets
v
+-------------------------------------------------------------+
| PASEO LOCAL AGENT |
| - Workspace Context Analyzer |
| - Bash/Terminal Execution Sandbox |
| - File System Watcher & git-diff integration |
+-------------------------------------------------------------+
|
+----------------+----------------+
| Secure APIs | Local API
v v
+--------------------------+ +----------------------------+
| CLOUD LLMs (OpenAI, | | LOCAL LLMs (Ollama, |
| Anthropic, DeepSeek) | | Llama.cpp, LM Studio) |
+--------------------------+ +----------------------------+
Because the Paseo Local Agent runs directly on your machine, it has secure access to your workspace. It can read your directory structure, analyze your import trees, run tests, and execute build commands—all governed by strict user-defined permissions.
Setting Up Paseo for Local Development
One of the best things about Paseo is how easy it is to bootstrap. Let’s walk through setting up Paseo to run locally, connecting it to a local Ollama instance running qwen2.5-coder for fully offline, private development, while also configuring a fallback to Anthropic’s Claude for complex tasks.
Step 1: Installing the Paseo CLI
Since Paseo is developer-first, the easiest way to get started is via the terminal. You can install the Paseo CLI and core agent daemon using your favorite package manager. For this example, we'll use Homebrew (macOS/Linux) or NPM:
# Install via NPM globally
npm install -g @paseo-ai/cli
# Or run it directly using npx
npx paseo initRunning paseo init will create a hidden configuration directory (usually ~/.config/paseo/) and generate a default config.json file.
Step 2: Configuring Your Models (Local + Cloud)
Let’s open up the ~/.config/paseo/config.json file and configure our LLM providers. We want to configure a local Ollama endpoint for fast, free, and secure auto-completions and refactoring, alongside an API key for Anthropic when we need deep architectural reasoning.
{
"default_agent": "local-assistant",
"providers": {
"ollama": {
"enabled": true,
"host": "http://localhost:11434",
"models": ["qwen2.5-coder:7b", "llama3.1:8b"]
},
"anthropic": {
"enabled": true,
"api_key": "env:ANTHROPIC_API_KEY",
"models": ["claude-3-5-sonnet-20241022"]
}
},
"workspaces": {
"allowed_paths": ["/Users/alex/projects/"]
},
"sandbox": {
"danger_zone_auto_execute": false,
"allowed_commands": ["npm test", "git status", "cargo test"]
}
}Notice the sandbox configuration. This is a crucial security feature of Paseo. When an AI agent decides it needs to run a terminal command (for example, running your test suite to verify a bug fix), Paseo won't just blindly execute it. You can define safe commands that are allowed to run automatically, while keeping dangerous commands (like rm -rf or database migrations) locked behind an explicit confirmation step.
The Power of the Multi-Client: Desktop, Mobile, and CLI
What makes Paseo truly unique compared to alternatives like Windsurf, Cursor, or basic chat UIs is its multi-client architecture. You are not locked into a single editor or a single screen.
1. The CLI Client: Pure Terminal Efficiency
If you are SSH'd into a remote staging server debugging a weird Docker configuration, you don't have a GUI. With Paseo, you can launch the interactive CLI client directly in your terminal:
paseo chat --workspace .This spins up a beautiful, terminal-based dashboard (using Textual/bubbletea-style rendering) that lets you interact with your workspace. You can ask the agent: "Review the recent logs in /var/log/nginx/error.log and suggest a fix." The agent will analyze the log file, write a bash script to update your Nginx config, and present the diff directly in your terminal UI for approval.
2. The Desktop App: Rich Visual Context
When you are back on your local machine, the Paseo Desktop App gives you a gorgeous, VS-Code-like split view. It features a file explorer, interactive diff viewers, and an execution dashboard where you can see the agent's reasoning steps, the terminal commands it wants to run, and the files it has modified.
Instead of copying a giant block of code, editing files manually, and tracking down syntax errors, Paseo displays a native git-diff viewer. You can accept or reject individual hunks of code generated by the agent with a single click.
3. The Mobile App: On-the-Go Hotfixes
We’ve all been there: you’re out at lunch, and a critical bug is reported. You don't want to pull out your laptop, tether to your phone, wait for everything to boot, and dive in.
Because Paseo supports a secure, self-hosted relay server, you can pair your mobile device with your local workspace securely (end-to-end encrypted). From the Paseo mobile app, you can query your active desktop workspace: "Are there any failing tests on the main branch?" or "Run the integration test suite and send me the traceback of any failures." If it's a simple fix, you can even instruct the agent to write a patch, run the tests, and push the branch to GitHub—all from your phone.
Writing a Custom Agent Workflow with Paseo
Paseo isn't just a static chat UI; it’s highly extensible. Let’s look at how we can write a custom agent workflow using Paseo's TypeScript SDK. This script automates the process of reading a bug report from a markdown file, finding the relevant code, writing a test to reproduce the bug, fixing the bug, and verifying the fix.
import { PaseoAgent, LocalWorkspace } from '@paseo-ai/sdk';
async function runBugFixer() {
// Initialize workspace context
const workspace = new LocalWorkspace({ path: './my-nodejs-app' });
// Initialize the Paseo Agent using Claude 3.5 Sonnet for reasoning
const agent = new PaseoAgent({
provider: 'anthropic',
model: 'claude-3-5-sonnet-20241022',
workspace: workspace
});
console.log("Analyzing workspace...");
await agent.analyzeContext();
const bugReport = await workspace.readFile('BUG_REPORT.md');
console.log("Instructing agent to diagnose and fix...");
const result = await agent.runWorkflow({
instructions: `
1. Read the bug report: ${bugReport}
2. Find the file in our workspace that contains this bug.
3. Write a Jest test inside the 'tests/' directory that reproduces the bug (it should fail).
4. Run the test command 'npm test' to confirm it fails.
5. Fix the underlying bug in the source code.
6. Run 'npm test' again to confirm the test now passes.
`,
autoApproval: {
// Allow the agent to read/write files and run npm test without prompting us
allowFileWrite: true,
allowedCommands: ['npm test']
}
});
if (result.status === 'success') {
console.log("Bug successfully fixed and verified!");
console.log("Diff of changes:");
console.log(result.gitDiff);
} else {
console.error("Workflow failed:", result.error);
}
}
runBugFixer();This level of programmatic control, combined with local sandboxing and visual client feedback, is what sets Paseo apart from basic wrappers. It treats AI as a programmable primitive in your engineering pipeline.
Conclusion & Next Steps
The developer community is moving past the initial hype of "AI chatbots." We are realizing that the value of AI in software engineering lies in integration, context awareness, and workflow ergonomics. Paseo hits the sweet spot. By keeping the interface open-source, local-first, and highly accessible across Desktop, CLI, and Mobile, it respects our development environments while vastly speeding up our loops.
If you’re tired of bloated browser tabs and want a streamlined, secure way to build with AI, Paseo is absolutely worth checking out.
What do you think?
Are you ready to migrate your AI workflows off web browsers and into a local-first interface? Have you experimented with running local models like Qwen or Llama for your daily coding tasks? Let me know in the comments below, or hit me up on Twitter/X at @sysseder!
Keep coding, keep building, and keep those browser tabs under control!