-
-
Real phone-to-Windows proof: a retired phone rebuilt as NightCity Desk Node with Codex and GPT-5.6.
-
A retired Xperia rebuilt as NightCity's first private, recoverable and bounded physical edge node.
-
Capture on Xperia, pull through the Bridge, verify integrity with SHA-256 and review in Windows Inbox.
-
Allowlisted actions, visible health and recoverable state—without exposing an arbitrary remote shell.
-
The same captured text appears intact in Windows Inbox.
-
A real attachment arrives with matching metadata and zero hash failures.
Inspiration
I am a creator, and several years ago I was also a full-time streamer and Twitch Partner.
During IRL streams, I needed a second phone just to monitor chat. One of my viewers gave me an old phone they no longer used. They warned me that it was slow, but it was still useful enough to help me stay connected with my audience.
Because of that history, this was never just another unused device.
Years later, the phone no longer had a purpose. At the same time, I kept seeing people buy small desktop displays and always-on smart screens. I started wondering why I should buy another device when I already had working hardware sitting unused.
At first, I only wanted to turn it into a simple desktop dashboard. Then the idea grew:
Could Codex and GPT-5.6 help one person research, learn, build, test, and deploy a real physical system?
The first time I sent an instruction and saw the phone respond, it felt different from simply chatting with AI. An idea that had existed only in my head was now running on a real device.
I had already been imagining a personal AI system called NightCity. This retired phone became its first physical node.
One retired phone. One new job.
What it does
NightCity Desk Node turns a retired smartphone into a private, bounded, and recoverable physical edge node.
The phone is not only a passive display. It participates in a real cross-device capture workflow:
- I enter text or select a small file on the phone.
- The item enters a controlled Capture Queue.
- A Windows computer pulls it through a private connection.
- The transfer is verified.
- The item appears in a desktop Inbox for human review.
The current system includes:
- Phone-to-desktop text capture
- Small-file and photo transfer
- Filename, type, size, and status metadata
- SHA-256 integrity verification
- Duplicate-safe synchronization
- A retained phone-side source record
- A reviewable Windows Inbox
- Allowlisted actions
- No arbitrary remote shell
- Visible health, recovery, and rollback state
- No public network exposure
The phone also runs a responsive local dashboard with pages for status, health, capture, tasks, maintenance, and future Codex-related workflows.
Features that are not ready are shown honestly as unavailable or setup-required rather than being presented as completed.
How we built it
Before Build Week, I already had basic Android, Termux, private SSH, and remote-wake foundations. They were useful starting points, but they were not yet the complete product shown in this submission.
During OpenAI Build Week, I used Codex and GPT-5.6 to turn those foundations into a working physical-node experience.
The new work included:
- The NightCity Desk Node control service
- A six-page responsive dashboard
- Nine local API routes
- A controlled Capture Queue
- A phone-to-Windows Capture Bridge
- A reviewable Windows Inbox
- Allowlisted task execution
- Mode persistence
- Health and recovery visibility
- Controlled reboot recovery
- Retained rollback state
- Real-device deployment and regression testing
The final implementation passed 15 local automated tests and was also validated on the real phone and Windows computer.
I worked through a repeated real-device loop: define a goal, make a bounded change, test it on the hardware, return screenshots or logs, correct the implementation, and test again.
I controlled the physical devices, installations, network access, security decisions, interface review, and final approval.
Codex acted as the implementation and debugging engineer. It inspected the workspace, wrote and modified Python, PowerShell, HTML, CSS, and JavaScript, added tests, investigated failures, and helped verify deployment, recovery, and rollback.
GPT-5.6 acted as the architect and critical reviewer. It helped break the work into safe gates, review permissions and privacy risks, challenge unsupported claims, separate verified features from future ideas, and refine the interface and final evidence.
GPT-5.6 is not running as an AI runtime on the phone. Codex and GPT-5.6 were used to build, reason about, test, review, and verify the project.
Challenges we ran into
The hardest part was not simply moving data between two devices.
The workflow needed to be private instead of publicly exposed, bounded instead of unrestricted, and verifiable instead of assumed.
Real hardware also introduced recovery risks. A mistake in a service, boot script, file path, or restart loop could make the device unreliable, so major changes needed clear stopping points, verification steps, and rollback paths.
Cross-device transfer required more than copying a file once. The system needed metadata, UTF-8-safe text handling, sanitized filenames, SHA-256 verification, duplicate protection, synchronization state, and retained source records.
Another challenge was packaging a private system for judges. The working environment contains device-specific paths and private network details that should not be public.
I therefore created a sanitized Submission Edition that preserves the architecture, documentation, and verification path without exposing credentials, private addresses, personal accounts, or environment-specific information.
Accomplishments that we're proud of
- A working physical node built from retired hardware
- A real phone-to-desktop evidence chain
- A controlled Capture Queue and reviewable Inbox
- SHA-256 integrity verification
- Duplicate-safe synchronization
- Allowlisted actions without an arbitrary remote shell
- Visible health, recovery, and rollback state
- Six dashboard pages
- Nine local API routes
- Fifteen passing automated tests
- Controlled reboot recovery on the real device
- A sanitized verification path for judges
- A complete working product rather than only a mockup
Most importantly, I started as a creator with an old phone and an idea, then used Codex and GPT-5.6 to build a system I can continue using.
What we learned
I learned that AI can dramatically shorten the distance between an idea and a working result, but it does not remove the need to understand decisions or verify evidence.
Codex was most effective when it could work from concrete files, test output, logs, screenshots, and real-device failures.
GPT-5.6 was most valuable when the problem involved architecture, scope, permissions, safety, recovery, or deciding whether a claim was actually supported.
I also learned that reliability often comes from limits.
Allowlisted actions, bounded storage, explicit modes, cooldowns, rollback, and honest unavailable states may sound less exciting than adding more features, but they made the system easier to understand and trust.
Finally, documentation, privacy review, testing, and reproducible verification are part of engineering—not tasks that happen after the real work is finished.
What's next for NightCity Desk Node
The next priorities are deliberately focused:
- Simplify setup and deployment
- Improve the local demonstration environment
- Refine the small-screen interface
- Expand compatibility with other retired Android devices
- Add carefully scoped capture actions
- Improve recovery guidance and accessibility
Future features will continue to follow the same principles:
Private. Bounded. Observable. Recoverable. Human-reviewed.
Log in or sign up for Devpost to join the conversation.