Connectra
Connect your machine
MCP-native · Early access

Every agent. Every device.
Connected by Connectra.

Connectra is a private outbound MCP bridge that lets your AI agents work with your local projects — through scoped filesystem access, approvals, diffs and rollback. Remote AI. Local authority.

Connect your machineExplore capabilities
No inbound ports · No public IP · No broad shell access
connectra-desktop — approvallocal authority
Change requestedpatch_filesrc/counter.rs

Remote AI proposed a targeted edit. Review the diff before it lands on disk.

counter.rssha-256 verified
4 struct Counter {
5- value: 1,
5+ value: 2,
6 }
~/Developer/experiments/connectrainside allowed root
Local authority decides
The problem

Your AI lives in the cloud. Your code doesn't have to.

Web-based AI clients can't safely reach your local machine. So developers bounce context between browser and terminal — every turn, every day.

The usual loop
  • Copy code into the browser01
  • Upload the project manually02
  • Push everything to the cloud first03
  • Switch to the terminal to run tests04
  • Paste the error back into the chat05
  • Repeat, every single turn06
with Connectra
The Connectra way
  1. 1

    Ask your AI

    “Fix the failing auth test.”

  2. 2

    Connectra bridges it

    The agent reads, patches and runs — over an outbound connection.

  3. 3

    Local project runs it

    You approve the diff. Tests pass on your machine.

How it works

Connect. Control. Execute.

Three steps from install to a full agent development loop running against your local repository.

GL
NK
RJ
TM
1

Step 1

Connect

Install Connectra Desktop and sign in through a secure device flow. The app opens an outbound connection — no inbound ports, no public IP.

Connectra Desktop

Tauri · Rust

connected
Sign in with your accountdevice flow
outbound websocketwss → control plane
2

Step 2

Choose

Select the Allowed Roots the AI is permitted to work inside. Everything outside stays invisible and unreachable.

Allowed Roots

where AI may operate

~/Developer/experiments/connectra
~/Developer/projects/acme-api
~/Documents/personal
3

Step 3

Work

Let your MCP-compatible agent discover, read, patch and run your project — with diffs and approvals at every sensitive step.

Agent loop

inspect → edit → verify

01search_filesfound auth module
02read_fileimpl + tests
03patch_filediff → approved
04run_commandverify locally✓
Architecture

A controlled bridge, not an open tunnel.

Requests travel down from the cloud to your machine. Authority travels nowhere — it stays on the desktop app that owns your filesystem.

01

AI clients

Any MCP-compatible agent

MCP client
MCP + authstreamable http
02

Connectra Control Plane

Cloudflare Workers · Durable Objects

authroutingdevice registry
outbound wsno inbound port
03

Connectra Desktop

Tauri · Rust · Local Authority

permission engineapprovalsnapshots
authority
permission engineallow · ask · deny
04

Local project

Allowed Root on your machine

filestestsbuilds
authority
The principle

Cloud requests actions. Local decides.

Capabilities

One bridge, every capability an agent needs.

Discovery, reading, mutation, execution and recovery — one verified MCP tool surface, bounded by local policy.

01
dev-machine-01online
list_devices

Discover devices

Find machines connected to your authenticated account.

02
auth*.rs6 found
search_files

Explore projects

Search files and inspect directory structure within a root.

03
mod.rsutf-8 ✓
read_file

Read code

Securely read supported source files — secrets stay blocked.

04
auth_test.rs
created+ snapshot
create_file

Create files

Generate new text and code files under approved directories.

05
- value: 1
+ value: 2
patch_file

Patch code

Apply precise transactional edits with SHA-256 concurrency.

06
config.tomlsha ✓
write_file

Rewrite files

Full-file replacement guarded by an optional expected hash.

07
$Run commands

✓ passed

run_command

Run commands

Structured, bounded execution — build, test, lint, git.

08
diff previewallow?
- old
+ new

Review diffs

See exactly what an agent wants to change before it lands.

09
snapshot · 14:02restore

Rollback

Snapshot history lets you restore previous local state.

Connectra Desktop · macOS / arm64 · early build

Agent workflow, illustrated

From request to green tests — on your machine.

A walkthrough of the loop: a web AI initiates the work, Connectra mediates every sensitive step, your local machine runs it.

You

Fix the failing auth test.

Security model

The cloud never becomes root.

Layered boundaries between a remote request and a local mutation. Hard boundaries can't be talked over — even by an approved agent.

01

Identity

Authenticated tenant with a secure device flow. Devices and sessions are scoped to you.

02

Device connection

Authenticated outbound desktop connection — no inbound listener.

03

Allowed Root

Operations must remain inside explicitly configured directories.

04

Canonical path validation

Traversal (`..`) and symlink-escape attempts are rejected.

05

Sensitive file policy

Secrets, binaries and archives are hard-blocked — approval can't override it.

06

Permission engine

Each operation is evaluated as Allow, Ask or Deny.

07

Human approval

Sensitive actions can require confirmation on the physical machine.

08

Optimistic concurrency

SHA-256 guards against stale writes over newer work.

09

Snapshot history

Pre-mutation state is preserved so changes can be reverted.

10

Local authority

Final execution happens under control of the desktop app.

allowed root + path guards+sensitive-file blocking+permission policy+local approval+sha verification + rollback
MCP native

Built for the agent ecosystem.

Connectra speaks the Model Context Protocol. If your client supports MCP, it can talk to your local machine through Connectra.

MCP clientsIDE agentsWeb assistantsCLI copilotsCustom agentsYour stack

Works through the open Model Context Protocol — any client that speaks MCP can connect. No official partnerships or endorsements are claimed; Connectra is infrastructure for the broader ecosystem.

Feedback · We read everything

Building in the open. Tell us what to fix.

Connectra is young and moving fast. If something breaks, feels wrong, or you have an idea — write to us directly. Every message reaches the people building it.

Send feedback

[email protected] · include your OS and build version if you can