Pocket Apps

Native apps for everyday ideas, built right on your iPhone.

Comment

Inspiration

I love building apps, and I love using them. AI has become an incredible accelerator for turning ideas into working software—especially the small, personal ideas that might never justify days of traditional development. Tools such as v0 and Lovable have made building software feel remarkably accessible, but they are primarily hosted experiences. I wanted something more personal: an app builder I could carry, use, and create with directly from my phone.

That question became Pocket: an app builder that runs with you. It explores a future where software can be created at the moment an idea appears, on the same device where it will be used.

What it does

Pocket closes the distance between an everyday idea and an app you can actually touch and use. Describe what you need, watch a Codex-powered builder design and test it, and then launch the result directly on your iPhone or iPad. Pocket Apps can use native capabilities such as the camera, photos, location, files, sharing, notifications, and on-device databases.

Pocket Apps are portable application bundles rather than traditional compiled iOS applications. The App Runner provides dynamic JavaScript execution, native SwiftUI rendering through Dynamic UI, persistence, tool access, and capability permissions. Apps that do not need network or agentic features can run locally and offline, while more complex experiences can launch their own focused Codex sessions. Finished Pocket Apps can also be shared with other Pocket users.

How we built it

The goal for the hackathon was delightfully recursive: use Codex to build an app that uses Codex to build apps. I also set a personal constraint of writing no code by hand. Codex, powered by GPT‑5.6 Sol at Ultra reasoning, handled the implementation while I directed the product, architecture, testing, and iteration. The result is not production-ready yet, but it is substantially more than a proof of concept—and it came together in one week.

Codex began by building the complete product experience: onboarding, authentication, the SpringBoard-style launcher, app creation, generated-app presentation, editing, annotations, settings, and the persistent builder conversation. Much of that initial interface required almost no visual correction. From there, Codex connected the system piece by piece: the Building Agent, App Runner, TypeScript compiler, native capability tools, dynamic SwiftUI renderer, persistence, validation, recovery, background execution, app sharing, and installation.

The foundation also came from projects previously built with Codex: swift-codex, swift-codex-ui, swift-appserver-client, swift-codex-ios, and swift-sdui. During the hackathon, Codex worked across those repositories, debugged behavior on physical iPhones and iPads, reproduced failures in Simulator, inspected memory graphs and device logs, and coordinated parallel subagents. At one point, multiple Codex instances and a fleet of three Simulators were used simultaneously to create and validate the baseline Pocket Apps included in the demo.

Challenges we ran into

The largest challenge was reliability. Pocket is asking an AI agent to create executable application bundles, compile TypeScript inside JavaScriptCore, render dynamic native interfaces, request sensitive capabilities, preserve a long-running conversation, and recover correctly when iOS suspends or terminates the host. A failure near the end of that pipeline cannot be allowed to discard twenty minutes of useful work, so durable drafts, actionable validation errors, recovery, and safe bundle sealing became core product features.

The project also pushed Codex itself into unusually demanding territory. The main development conversation eventually grew to almost 2 GB, while context cloning across subagents consumed significant disk space. Long transcripts, concurrent agents, embedded compilers, previews, and physical-device debugging exposed memory and resource-management problems that ordinary app development rarely reaches. It highlighted the need to keep improving the experience for the most ambitious, high-intensity Codex workflows.

To build this up Codex had to launch over 297 subagents!

Accomplishments that we're proud of

Pocket is an idea I had been circling for a long time. While bringing Codex to iOS for other projects—including an iPadOS port of OpenSCAD—I gained many of the pieces needed to attempt it, but never found the right opportunity to explore dynamic apps as a complete product.

It was always an ambitious idea. I am not only proud that it was built in a week; I am proud that it was built at all. Before Codex, this is exactly the kind of project that might have reached a half-working prototype before being left to collect dust in an old repository. Instead, Pocket can create, modify, validate, run, persist, and share native-feeling applications directly from an iPhone or iPad.

What we learned

The newest models do more than accelerate familiar engineering work—they expand the scope of what feels reasonable to attempt. I began the week expecting to cut Pocket’s scope dramatically. Instead, the project reached app creation, native capabilities, dynamic interfaces, persistent data, agent sessions, recovery, background work, app sharing, and physical-device validation.

I also learned that successful agentic development depends heavily on the quality of the feedback loop. Agents need precise runtime contracts, fast previews, actionable errors, isolated workspaces, and the ability to recover instead of restarting. Improving those boundaries often produced a larger gain than changing the prompt.

Finally, this project changed how I work with Codex. Coordinating subagents and multiple Codex instances made it possible to investigate architecture, implementation, testing, and debugging in parallel. That workflow still has real resource costs, but GPT‑5.6 Sol feels like another step up the staircase: capable of sustaining much larger goals when given the right environment and enough autonomy.

What's next for Pocket Apps

The next step is turning Pocket into a real product. The first uncertainty is how Apple’s App Review process will treat an application that can create and execute dynamic Pocket Apps. Building it is part of discovering what is technically and product-wise possible, even if the App Store is not ready for this model yet. If necessary, Pocket can launch through another distribution path while that landscape develops.

A second path is to bring the Building Agent to macOS and allow Pocket Apps to graduate into independently packaged iOS applications. Pocket could become the place where an idea begins, is tested, and evolves—before eventually becoming a standalone app distributed outside the building platform. It would be amazing to one day discover an App Store application that began its life as a Pocket App.

The immediate goal is simpler and concrete: keep improving reliability, place Pocket in more people’s hands, and publish the first Pocket-built application on the App Store by the end of August.

Built With

  • ai-agents
  • app-builder
  • app-server
  • background-tasks
  • camera
  • codex
  • dynamic-ui
  • generative-ui
  • gpt-5.6
  • ios
  • ipados
  • javascriptcore
  • location-services
  • multi-agent
  • native-apps
  • on-device
  • openai
  • server-driven-ui
  • simulator
  • sqlite
  • swift
  • swift-package-manager
  • swiftui
  • typescript
  • xcode
Share this project:

Updates