Unfour

A local-first desktop workspace for backend developers that combines API debugging, SSH terminals, and database management — and exposes them to your AI agent through a local MCP server.

Comment

Unfour — An AI-Powered Workspace for Backend Debugging

About the Project

Unfour is an open-source desktop workspace that helps backend developers investigate and solve problems with Codex.

It brings together three tools that developers frequently switch between:

  • API testing
  • SSH terminal access
  • Database exploration

Instead of asking developers to manually move information between an API client, an SSH terminal, a database tool, and an AI assistant, Unfour exposes these capabilities to Codex through MCP. This allows Codex to help with an entire debugging workflow: reproduce an API issue, inspect server logs, query the database, compare the results, and suggest the next step.

The goal is not simply to place several developer tools inside one application. The goal is to give an AI coding agent enough structured access to investigate real backend systems safely and effectively.

What Inspired Me

The idea came from a common backend debugging experience.

When an API returns an unexpected result, I often need to:

  1. Reproduce the request in an API client.
  2. Connect to a server through SSH.
  3. Search logs or inspect a running service.
  4. Open a database client and query related records.
  5. Copy the information into Codex and explain the context.
  6. Repeat the process after every new finding.

Each tool works well independently, but the overall workflow is fragmented. A large amount of time is spent switching applications, copying data, and rebuilding context for the AI.

I wanted to explore a different model: instead of manually giving Codex isolated pieces of information, what if Codex could use the same operational tools as the developer?

That question became Unfour.

How I Built It

Unfour is built as a cross-platform desktop application using Tauri 2.0, Rust, React, and TypeScript.

The application currently includes:

  • An API client for organizing and sending HTTP requests
  • An SSH terminal for connecting to remote environments
  • A database client for PostgreSQL, MySQL, and local data exploration
  • A local workspace system for managing related connections and requests
  • An MCP server that exposes Unfour's capabilities to Codex

The architecture separates the user interface from the underlying engines. API requests, SSH sessions, database queries, local storage, secrets, diagnostics, and MCP commands are implemented as independent modules.

For the MCP integration, I focused on providing small, structured operations instead of one large autonomous command. Codex can use individual tools to send an API request, inspect a database, or execute an approved SSH operation. It can then combine those results into a broader debugging process.

For example, Codex can:

  • Call an API and identify an incorrect response
  • Check related application logs through SSH
  • Query the database to verify the stored state
  • Compare the API response with the database result
  • Explain the likely cause of the issue

Unfour is local-first. Connection details and workspace data stay on the user's machine, and sensitive values are handled separately through secure storage.

Challenges I Faced

One of the biggest challenges was deciding how much control to give the AI.

SSH and database access are powerful, but they can also be dangerous. I needed to think beyond whether a tool could execute a command and consider whether it should execute it automatically.

This led to a permission model based on environments and operation types. Development environments can allow broader access, while test and production environments can default to read-only or require confirmation for risky operations.

Another challenge was designing MCP tools that are useful to an agent. Existing user interface actions do not automatically become good agent tools. Each tool needs:

  • A clear purpose
  • Predictable inputs
  • Structured outputs
  • Useful error messages
  • Narrow permissions
  • Enough context for Codex to decide what to do next

I also faced several desktop engineering challenges, including cross-platform packaging, database migrations, terminal process management, secure credential storage, and keeping the open-source Community edition aligned with the future Pro edition.

A particularly interesting issue involved the MCP process lifecycle. When Codex launched the local MCP server, the process could remain active and lock application files during a later build or update. Solving this required treating the MCP server as a real long-running product component rather than a simple development script.

What I Learned

The most important thing I learned is that AI-assisted debugging depends heavily on context and tool design.

Codex can reason well about a backend problem, but only when it has access to reliable evidence. A good prompt is useful, but direct access to structured API responses, logs, and database results is much more powerful.

I also learned that tools designed for humans and tools designed for agents have different requirements. Human interfaces can rely on visual context and implicit state. Agent tools need explicit schemas, stable identifiers, clear boundaries, and machine-readable results.

Another lesson was that trust must be part of the architecture. An AI agent should not receive unrestricted infrastructure access by default. Permissions, confirmations, audit logs, and environment boundaries are core product features, not optional security improvements.

Finally, I learned that combining tools is not enough. The real value comes from connecting them into a coherent workflow. Unfour becomes useful when Codex can move from an API symptom to server evidence and then to database verification without losing context.

What Is Next

The next step is to make the debugging workflow more guided and reliable.

I plan to add:

  • Safer workspace-level permission policies
  • Better diagnostic and audit logs
  • Reusable debugging workflows
  • Improved MCP tool descriptions and schemas
  • One-click Codex configuration
  • Clearer separation between development, test, and production access
  • More complete API, SSH, and database capabilities

The long-term vision is for Unfour to become a shared workspace where developers and AI agents can investigate backend systems together.

Instead of replacing the developer, Codex acts as an investigation partner: gathering evidence, connecting information across systems, and helping the developer reach the root cause faster.

Built With

  • ai-agents
  • api-testing
  • backend-development
  • codex
  • database-tools
  • debugging
  • developer-tools
  • devops
  • local-first
  • mcp
  • open-source
  • openai
  • rust
  • ssh
  • tauri
Share this project:

Updates