DevRunX

Remote operations for long-running work

Know what your systems are doing. Act when they need you.

DevRunX is being built as one place to observe long-running work, understand what changed, and take controlled action across connected systems — without staying tied to the machine where the work started.

Join early access View how it works

The platform is under active development. Product status is shown clearly below.

Operations

Recent events

Build completedproject workspace
now
Agent task startedresearch workflow
recent
Process needs attentionbackground worker
recent

Active session

dev-workstationterminal session
connected
agent-runlong-running task
observing

Quick actions

⌁ Inspect ↻ Restart ▣ Events → Action
TerminalEventsSummary
dev@workstation:~/project $ npm run build
building application…
✓ build completed successfully
waiting for next task…
Computers & devicesworkstations and devices
Serversremote runtimes
AI agentslong-running agent work
Applicationsprocesses and jobs
Cloud servicesservices and deployments
Automationsscheduled and event-driven
APIs / toolsfuture integrations

These categories show the intended platform boundary; they do not imply every connector is available today.

workspace · activity
TerminalEventsSummary
dev@workstation:~/project $ npm run build
› compiling application
✓ compiled successfully
✓ checks completed

EVENT build.completed
source: workstation · project workspace

dev@workstation:~/project $ ▋

What it does

Monitor. Control. Keep work moving.

DevRunX is being built for work that continues after you leave the screen. Observe activity, understand when something changes, inspect the useful context, and take a controlled action without returning to the originating machine.

01See activity

Bring relevant process, session, and event state into one operational view.

02Understand change

Surface the event or state transition that actually needs attention.

03Take action

Move from visibility to an intentional, controlled response when the system supports it.

How it works

Connect. Observe. Act.

DevRunX is designed around a simple operating loop rather than another dashboard you have to babysit.

01

Connect

Add a device or supported system and establish an authenticated relationship.

02

Observe

Receive real-time or near-real-time activity, events, state, and useful summaries.

03

Act

Run an approved action or command when intervention is actually needed.

Product principle

Context before control.

Remote control without context is risky and noisy. DevRunX is being shaped around understanding the state of work first, then exposing the smallest useful action.

State
What is running, waiting, completed, stopped, or needs attention.
Events
What changed and when, without forcing you to watch a live terminal continuously.
Actions
Controlled intervention tied to the session, device, and context that produced it.

Product status

What exists — and what does not yet.

The boundaries below are intentional. A data model or planned connector is not presented as a finished product surface.

Current codebase

Available foundation

Core identity and device/session foundations are present today:

  • Account registration/login foundation
  • Web account and profile surface
  • Device and session model
  • Time-limited pairing-code flow
  • Terminal-device pairing
  • Terminal-device session/token issuance
  • Role-aware device model
  • Backend rate-limiting foundations
Being built

In development

The operational experience is still being completed and verified:

  • Real-time session visibility
  • Terminal/event streaming
  • Richer device management
  • Controlled remote actions
  • Audit-log user experience
  • AI-generated session/event summaries
  • Robust reconnect/recovery behavior
  • Operational dashboard views
  • Notification workflows
Platform direction

Future

These describe the broader source-agnostic platform direction, not current connector availability:

  • Broad AI-agent connectors
  • Application connectors
  • Cloud-service connectors
  • Automation connectors
  • Cross-system orchestration
  • Richer notification channels
  • Policy-driven action approval
  • Broader source-agnostic remote execution/control
  • Team-oriented operational workflows

Use cases

For the work that keeps going.

The point is not to stare at another console. It is to know when long-running work needs you — and when it does not.

01

A build is still running after you leave your desk.

Check its state and the useful output without reopening the original workstation.

02

An AI agent needs attention.

See that the run changed state and inspect the context before deciding what to do next.

03

A server process exits unexpectedly.

Surface the event and make the supported recovery path easier to reach.

04

A long-running task finishes.

Know that the job completed instead of repeatedly checking the machine that started it.

05

A deployment or automation changes state.

Bring the transition into the same operational context as the systems around it.

06

You are away from the originating machine.

Keep enough visibility to understand what is happening while the work continues elsewhere.

Architecture at a glance

Connected systems. One operational loop.

This is a public product-level view. It intentionally omits private implementation and infrastructure details.

Early access

Help shape what DevRunX becomes.

Early access is for people running work that continues when they are no longer in front of the machine — developers, founders, DevOps operators, and people working with AI agents.

External form Join early access

The signup asks for Email and Role, with optional Name and “What would you want DevRunX to monitor or control?”

Responses are handled by the external form provider; this static overview site does not store submissions.

The Tally form connection is pending.