Providence

Logo and slogan
Landing page on left, logo middle, working superagent on the right, all three laptops have full access to the others, intuitive!

Inspiration

We love building with AI, but we kept finding ourselves doing the coordination. One conversation had the plan, another had the code, and another had useful research. We were constantly repeating instructions, copying context, and checking whether the work had actually finished.

That became even more frustrating when we stepped away from our computers. We wanted to keep work moving without reopening every conversation and explaining everything again.

We built Providence to bring those conversations and devices together through one assistant.

What it does

Providence lets you direct work across your connected computers through one superagent. It reads relevant context from the conversations you connect, delegates tasks to agents on the appropriate devices, and brings their progress, files, and results back into one place.

Each computer runs its own agent with access to that device’s available tools and permissions. The superagent coordinates the work: it can send independent tasks to different agents simultaneously or arrange dependent steps so the next agent receives the previous agent’s results.

For example, a Mac agent can build a webpage, a Windows agent can prepare its release summary, and another Mac agent can review the implementation and rerun its tests. You can follow the entire workflow from the main conversation while opening individual conversations whenever you need more detail.

The web interface is the central workspace. Apple Watch, iPhone, and Quest clients provide additional ways to interact with the same coordinator. Voice input and spoken replies let you direct work without typing.

How we built it

We built a TypeScript and Node.js coordinator, a React web interface, and WebSocket connections between the coordinator and device agents. OpenAI Codex powers the agents’ reasoning and execution tools. We also used Codex throughout development to write code, debug problems, review changes, and build automated tests.

The coordinator tracks conversations, tasks, dependencies, approvals, and results. When one task depends on another, it waits for that task to finish and passes fresh context into the next step. Agents can publish files back to the workspace, where their contents and revisions can be verified.

We built the Watch interface with SwiftUI, an iPhone app around the shared web workspace, and a Quest client using Three.js and WebXR. We integrated ElevenLabs for transcription and spoken responses.

Much of the engineering went into connecting these components reliably: preserving request identities, handling disconnects, preventing duplicate submissions, keeping permissions explicit, and distinguishing a completed assistant response from completed work.

Challenges we ran into

The hardest part was keeping the interface aligned with what was actually happening.

A superagent could finish replying while a worker was still running. A device could disconnect after receiving a request but before returning its result. An approval could be answered without the response reaching the coordinator. Retrying blindly could repeat an action that had already happened.

We had to make those uncertain states visible and preserve enough information to recover without pretending the work had succeeded or automatically doing it again.

Cross-device context was another challenge. Passing everything into every task creates noise and mixes unrelated conversations. We built explicit context transfers so an agent receives relevant information while the source conversations remain identifiable.

We also worked to keep the interface simple. The main conversation should be easy to follow, while individual tasks, permissions, transcripts, and files remain available when the user needs them.

Accomplishments that we’re proud of

We got requests from the web interface to perform real browser and native-app actions on a Mac and return the results.

In a test scenario, a Mac agent built a signup page, a Windows agent prepared its release summary, and a separate Mac agent reviewed the work and reran the tests. That demonstrated the workflow we wanted: different agents contributing to one task without the user manually carrying context between them.

In a team test, a typed Apple Watch request opened a page on the Mac and returned the result to the Watch. We also verified a browser voice request flowing through transcription, a real Mac action, and spoken output.

We brought the coordinator, web and Quest interfaces, Watch app, iPhone shell, and backend work into one repository. The combined source passed automated tests and builds, including Watch and iPhone simulator builds.

What we learned

An agent saying “done” is not enough. The application needs to know which device performed the work, what actually changed, and whether the result can be checked.

We learned that useful multi-agent software depends as much on coordination and recovery as it does on model capability. Context has to reach the right agent. Dependencies have to wait for real results. Permissions have to remain meaningful. Uncertain outcomes have to stay uncertain until there is evidence.

We also learned the value of a concrete workflow. Watching several agents contribute to one finished result explained Providence more clearly than any architecture diagram could.

What’s next for Providence

We want to make connecting a new device as simple as joining a conversation. We plan to improve onboarding, make relevant conversations easier to find, and give users clearer control over which context moves between agents.

We also want faster, more natural voice interactions and a more useful experience across Watch, iPhone, and Quest. For longer workflows, we plan to improve progress updates and make it easier to return to completed results without searching through individual chats.

Our goal is to make Providence useful throughout the day: one place to direct work, follow its progress, and receive results, whether we’re at a desk or away from our computers.

Built With

cloudflare
codex
github
nginx
node.js
openai
react
swift
swiftui
three.js
typescript
vite
watchos
websockets
webxr

Submitted to

Hack the North 2026
- Winner Aramco Americas: Best Beginner Hack

Created by

I started on the hardware with Abrahim. I wrote the firmware for our haptic wearable, an ESP32 board driving vibration motors and reading its sensors, and I wrote the Python driver that controlled it over USB. When it became clear the hardware would not be ready in time for the demo, we both moved onto the software Hani and Yusef were building.

There I took on the coordinator's reliability, the part that keeps Providence running when a computer drops off or something fails halfway through a task. I added reconnects with limits and backoff so a Mac or Windows machine that lost its connection came back on its own, per-request timeouts so one stuck call could not freeze the interface, and automatic restarts for the Codex process when it exited. I made the saved task and chat state survive crashes, half-written files, and two processes writing at once, so the coordinator could always start again, and added health reporting so the interface showed when something was degraded. I also set up the Windows worker, made the test suite pass on Windows, added the GitHub Actions checks, and consolidated the team's docs.

Abdalla El doumani
I primarily built Providence’s backend and Codex integration, connecting agents across devices through one superagent. My work included browser and native-app Computer Use, cross-device task routing, context sharing between conversations, persistent task and chat history, task dependencies, permission handling, device pairing and reconnection, and verified file delivery. I also integrated these capabilities into the shared interface so users could direct work, follow progress, and receive results in one place. This lets work span multiple computers, using each device’s available tools and permissions, without users having to manually move context between conversations.

Hani Zaidi
oh yeah
I developed Providence’s Apple Watch client in Swift and SwiftUI and integrated it with our team’s TypeScript computer-control backend. The Watch interface lets users submit spoken requests, select a connected computer and conversation, monitor task progress, respond to approvals, and hear results from their wrist.

My main focus was making the connection between voice input and computer execution reliable. I implemented exact device and conversation selection, preserving request identities throughout transcription, submission, and recovery. I added recovery handling for interrupted requests and lost acknowledgments so the app could check an existing operation rather than blindly submit a new one. I also implemented Watch-side selection for workflows spanning three computers, assigning research, analysis, and presentation roles to specific devices.

To avoid premature success messages, I added checks against child-task completion, device and conversation bindings, and published artifact metadata before reporting that workflow outputs were ready. I contributed regression tests for routing, request recovery, approval handling, and workflow state.

Beyond the Watch client, I extended the reviewed-email workflow with spoken recipient clarification and address correction, integrated ElevenLabs speech output, and added a native iPhone shell around the shared web application with restricted navigation, microphone permissions, and artifact-sharing support. I also contributed to pairing improvements, backend reliability fixes, TestFlight distribution, and integration of the team’s component branches.

Yusef Syed
Abrahim Mohamed