AI-native iOS apps

GunnarHostetler.

I look for better ways to do things, and I build software to solve problems I run into.

I have four apps on the App Store.

70App Store releases
2,512Commits in 2026
1,500+App downloads

A look inside

OpenIntelligence

↗

When is my rent late, and what's the fee?

Rent is considered late if it is received after 11:59 p.m. on the 5th day of the month, with a late charge of $75.00 applying, and the total late charge is capped at $150.00 for any one month S7. Monthly rent is $1,675.00, due on the 1st day of each month S7. A returned payment costs $35.00 S7.

Fact check: 3 of 3 supportedOn-device, 15.2 s

From the source Juniper Flats Lease - Unit 4B.pdf, page 1, section 5

Juniper Flats Lease - Unit 4B.pdfpage 1

4. Rent

Monthly rent is $1,675.00, due on the 1st day of each month. Rent is paid through the resident portal or by check delivered to the leasing office. Rent is fixed for the Term.

5. Late Charges

Rent received after 11:59 p.m. on the 5th day of the month is late. A late charge of $75.00 applies on the 6th, plus $10.00 per day after that, with total late charges capped at $150.00 for any one month. A returned payment costs $35.00.

How it found this

Recorded in OpenIntelligence 5.6 in the iPhone Simulator on my Mac, Oct 8, 2026 · made-up sample documents · Every question I asked it for this demo, misses included

Selected Work

OpenIntelligence

5.7 · Oct 22, 2026 · open source
Flagship

My on-device RAG app for iOS and macOS, built completely around Apple Intelligence/Foundation Models frameworks. It answers questions from your own files, cites the exact page every claim came from, and tells you when your files don't say it.

Answers on your device, or, on iOS and macOS 27, on Apple Private Cloud Compute after you approve what is sent.

Why I built it

When Apple opened its on-device foundation model to developers at WWDC 25, I had this obsessive urge to see how far I could push it. The first useful query ran straight into the model's tiny 4,096 context ceiling.

What makes it tick

  • I kept tearing at that problem until the app could carry evidence across fresh reasoning sessions, cite its sources, and refuse an answer when its critical checks fail.
  • Parsing, Vision OCR, indexing, SQLite FTS5 and vector search, reranking, evidence packing, citation checks, and abstention all run on-device.

What it runs on

Apple IntelligenceFoundation ModelsConsent-Gated PCCAgentic Reasoning LoopVision OCRSQLite FTS5

Why: I wanted private document search that did more than produce a confident paragraph. I wanted to ask a question, inspect the evidence behind the answer, and know whether it ran on my device or used an Apple-managed route. That became OpenIntelligence: a native document workspace built around retrieval, citations, verification, and explicit execution policy.

Private Cloud Compute routing: Version 5.7 decides where final synthesis runs only after retrieval, when the evidence and real context size are known. On iOS and macOS 27 a long evidence-heavy request uses Private Cloud Compute only after you have seen how much would be sent and why, and given permission; on older systems every route resolves on-device. Retrieval and verification stay local, and every answer carries a route badge.

Local retrieval & verification: Parsing, Vision OCR, indexing, SQLite FTS5 and vector search, reranking, evidence packing, citation checks, and abstention all run on-device. The app still works in airplane mode through its on-device answer path and does not require an account or API key.

More than PDFs: The ingestion pipeline handles Office documents, spreadsheets, presentations, notes, scans, code, images, audio, and video, then keeps those different sources searchable inside the same private library.

Building in the Open: Since releasing it, I’ve opened up the project to the public. To manage the workflow, I set up a single-source-of-truth Notion roadmap and built custom agentic skills, meaning AI assistants can now log bugs and add features to the roadmap directly from the terminal as I build.

What I learned: The model call is the easy part. The real work is getting the right evidence, preserving source structure, handling ugly files, refusing unsupported answers, and making the whole route visible enough that a user can verify what happened.

Itinerary to a cardiPhone
From the paper to the codeiPhone
Every claim, checkedMac

OpenManual

1.7.2 · Nov 10, 2026

My iPhone app that reads the label on a device with Apple's Vision framework and goes and finds its manual. If it's a medical device, you can scan its UDI barcode and it pulls up its FDA record and any recalls.

There's no OpenManual server, no account and no API key, and what the camera sees and the PDFs you import stay on your phone.

Why I built it

I literally save every single manual I get for any device I own, and finding the right one for the exact model in front of me has always sucked. So I built OpenManual.

What makes it tick

  • If there's a UDI on the label, the FDA's AccessGUDID database tells it the exact device. If there isn't, it reads the plate, ranks the likely matches and asks you the one question that narrows it down the most.
  • I built a Python backend and a Cloudflare search proxy for this, then deleted both on purpose, so there's no server to keep running and no key inside the app.

What it runs on

Foundation ModelsVision OCRVisionKitPDFKitAccessGUDIDopenFDA

Why: The reason is simple, I have this thing where I keep the manual to basically everything I buy, like if it’s a medical device or a household appliance, they typically come with a manual I save because I know at some point I’m gonna have a question about it and I want the actual document.

The point of this app is to find the manuals and IFUs on websites that don’t require logins or manual searching. I’ve used it on some pretty old devices and it’s found the manuals to them, when I went onto the manufacturer’s website and they weren’t anywhere to be found.

Identity first: If there’s a UDI on the label, AccessGUDID tells it the exact device. If there isn’t, it reads the plate, ranks the likely matches and asks you one question to narrow it down. The full UDI never leaves the phone, only the part that names the model does.

Finding the manual without a server: There’s no key for a search service inside the app, so it searches the maker’s own site, the Internet Archive and public search engines itself and falls back to a web search in Safari. And because it shows up as Open in OpenManual when you share a PDF, a manual you open yourself behind a manufacturer’s login can get in too, which no crawler ever could.

On-device from there: PDFKit reads the manual, it’s split up and searched right on the phone, and the answer is quoted from the manual with the page it’s on. A PDF it finds might be the one and might not, so you say yes before it’s saved to that device.

Medical boundary: It finds and quotes documentation. It doesn’t diagnose, recommend treatment or pick settings for a specific person. Medical devices got the strictest rules first, and it does the same job for appliances, tools and cars.

What I learned: I built a Python backend and a Cloudflare search proxy for this, then deleted both on purpose, because I didn’t want a server to keep running or a key inside the app. Reading a label all the way to the exact device works against the FDA’s live databases, and answering from a manual you kept was working before the first public build.

OpenManual App Store screenshot 1OpenManual App Store screenshot 2OpenManual App Store screenshot 3OpenManual App Store screenshot 4
A UDI scan to the manual, with the search sped up 3x

OpenResponses

2.9 · Oct 2, 2026 · open source

My iOS app for OpenAI's Responses API, on iPhone and iPad. It lets the model do real work on your phone, like adding calendar events and contacts or running Python, and connect to MCP servers.

Native computer use and MCP connectors, passed App Review on the first try

Why I built it

OpenAI announced they were deprecating the Assistants API, and my immediate thought was "they're killing my first app!" (OpenAssistant), so I opened VSCode with OpenAssistant in one window and OpenResponses in another, using LLMs to help swap out all the endpoints and rebuild the flow on the new Responses endpoints.

What makes it tick

  • I built a custom streaming interface that translates browser tool-calls (clicking, typing, scrolling, screenshots) into a native Swift environment, letting the model navigate web pages in real time.
  • I integrated Model Context Protocol (MCP) connectors and Apple EventKit, allowing it to search and read Gmail, Google Calendar and Dropbox, connect to Notion, and create Apple Reminders and calendar events.

What it runs on

Responses APIMCP ConnectorsComputer UseEventKit ToolsSSE StreamingRealtime Voice

Why: OpenAI announced they were deprecating the Assistants API, and my immediate thought was “they’re killing my first app!” - OpenAssistant - so I opened VSCode with OpenAssistant in one window and OpenResponses in another, using LLMs to help swap out all the endpoints and rebuild the flow on the new Responses endpoints.

Computer Use: I built a custom streaming interface that translates browser tool-calls (clicking, typing, scrolling, screenshots) into a native Swift environment, letting the model navigate web pages in real time.

Connected Tools: To give the model access to the real world, I integrated Model Context Protocol (MCP) connectors and Apple EventKit, allowing it to search and read Gmail, Google Calendar and Dropbox, connect to Notion, and create Apple Reminders and calendar events.

Version 2.9 (October 2026): You can see what the assistant is doing while it uses its tools. Each tool step shows a spinner while it works and says Completed or Failed when it’s done, steps go by their real names, and the Code Interpreter step shows the Python it ran. A chart from Code Interpreter shows once, and each file it makes is listed once. It builds on 2.8’s GPT-6.1 Sol, new OpenAI models that show up in the menus on their own, Python that runs on the phone after you approve each run, which passed App Review on the first submission, and search by meaning with Apple’s on-device language model.

What I learned: Because of all the App Store Connect rejections on my first two apps, I learned exactly what reviewers looked for. I got this one passed through review without a single rejection on the first pass.

OpenResponses App Store screenshot 1OpenResponses App Store screenshot 2OpenResponses App Store screenshot 3
A photo of a schedule onto the iPhone's calendar, with the wait sped up 12x

OpenCone

3.1 · Oct 2, 2026 · open source

My iOS app that meshes the OpenAI and Pinecone APIs together to form a RAG client for testing multi-index document search. It started on the Completions API and now runs on the Responses API.

The Pinecone iOS client that didn't exist, with on-device PDF and OCR chunking

Why I built it

When I started getting into deeper development with OpenAssistant, the app would start losing context during large document queries. I looked up vector databases, found Pinecone was the standard, and realized they didn't have an iOS app, so I decided to build one.

What makes it tick

  • To feed documents into Pinecone, I built a local parser using Apple's PDFKit and Vision.
  • To prevent the app from lagging or getting stuck when a server fails, I built a network circuit breaker. If Pinecone fails twice in a row, the app automatically pauses requests and lets the user know immediately.

What it runs on

Responses APIPinecone REST APIPDFKitCircuit BreakerSpeech RecognitionSSE Streaming

Why: When I started getting into deeper development with OpenAssistant, the app would start losing context during large document queries. I looked up vector databases, found Pinecone was the standard, and realized they didn’t have an iOS app, so I decided to build one. I wanted to query multiple indexes and namespaces in a single chat thread, which was something the OpenAI Assistants playground was limited in doing.

On-Device File Reader: To feed documents into Pinecone, I built a local parser using Apple’s PDFKit and Vision. It extracts text from PDFs, text and code files, and reads the text in images with OCR, automatically chunking and converting them into embeddings on the fly.

Network Safety: To prevent the app from lagging or getting stuck when a server fails, I built a network circuit breaker. If Pinecone fails twice in a row, the app automatically pauses requests and lets the user know immediately.

What I learned: I took the backend from OpenAssistant and swapped out the storage layer for Pinecone. Honestly, in retrospect, the initial interface looked awful, but I later rebuilt it with the Responses API and clean embeddings. Getting this on the App Store was a personal milestone.

OpenCone App Store screenshot 1OpenCone App Store screenshot 2
OpenCone 3.1, filmed in the iPhone Simulator on my Mac, sample documents

My first shipped iOS app, built around the OpenAI Assistants v2 API. It handled vector stores, document uploads, active run polling, and strategy-driven local file preprocessing.

Where I learned to ship: App Store approval after 30 rejections taught me the reviews

Why: When ChatGPT-4 first came out, it BLEW my mind. Their official app was slow, crashed, and limited me to 5 files at a time. I got curious about their API, saw people making wrappers, and thought, why would I pay for someone else’s app when I can just build my own?

File Formatting: OpenAI, at the time, would reject standard iPhone files (like live HEIC photos or RTF documents) when uploaded. To fix this, I set up a local conversion system that automatically turns these files into standard JPEGs and plain text on the device before sending them off.

“Is it done yet?”: Since OpenAI’s Assistants API didn’t respond instantly, I built a timer system that checks in with OpenAI every 2 seconds to see if the assistant is done thinking, so the app can display the answer the second it’s ready.

What I learned: Making an iOS app isn’t easy. I built it by copying OpenAI API references into text files, uploading them to a playground vector store for context, and copying and pasting the red errors back in to get corrected code. I repeated this until it worked, spent $99 on a developer account, and finally got it on the store after being rejected upwards of 30 times because they kept telling me everything that was wrong with my app.

Where it stands: Archived. The Assistants API it was built on is shut down now, which is the whole reason OpenResponses exists. It’s no longer on the App Store, and I’m not developing it further. Everything I learned getting this one approved went into the four apps after it.

Repo History

What the Work Looks Like Over Time

Synced · Nov 17, 2026
Sep '24OctNovDecJan '25FebMarAprMayJunJulAugSepOctNovDecJan '26FebMarAprMayJunJulAugSepOctNov
Less
More

How I Build

I am a tinkerer at heart. I don't know why I build as much as I do. It's an itch that the only way I know how to scratch is by feeding my relentless curiosity with perpetually more complex systems and integrations. I look for better ways to do things even when I'm not trying to, and even when something isn't broken, I still try to optimize it.

I'm an information junkie, and I have so much energy and motivation to build stuff, daily, and it seems to only have grown over time. I pretty much always have an agent building something, and I voice my deepest prompts now, it's become one of the most useful parts of how I build/iterate. It's as maddening as it is invigorating.

I've wanted to build software for a long time, but I didn't have a way to get from “I wonder if this could exist” to actually making it exist.

LLMs changed that for me. I leverage AI and RAG architectures to build the working foundations of my apps through the literal ingestion of complex API documentation. Once the core foundation is set, I build the real structure around it and just go nuts filling in the gaps.

Right now, I'm using Google Antigravity, Claude Code, and OpenAI Codex. Most nights are me building because I can't not. If it's something new, I feed them docs, test what comes back, and figure out how to make it work. Once it works, the sky is the limit.

My process is built on relentless, iteration-driven execution.

I use AI as an implementation partner to move through code, documentation, errors, and debugging fast enough to stay with the idea. I still decide what the thing should do, how it should feel, and whether it's actually useful. When models hand me something, it's hardly gold, and the whole job is knowing when plausible isn't true.

I've learned to just roll with the chaos of building, and because of that, I have created things I never thought I'd be able to.

At the end of the day, the things I make still have to work. They have to run, handle real inputs, survive weird edge cases, and function well for the reasons they were built in the first place. I ship things I'd genuinely use.

Track Record

AI-Native iOS Developer

iPhone, iPad and Mac apps on the App Store

Oct 2024 to Present

When GPT-4 was released, I used it like mad and eventually got tired of waiting for OpenAI to ship an Assistants API client in their iOS app. They never did. So I built it.

5
Apps shipped
4
On the App Store now
70
App Store releases
2,512
Commits in 2026
  • I asked ChatGPT if I could build my own iOS app on OpenAI's API. It said yes. I'd never written Swift.
  • I copied the API docs into text files, pasted Xcode's errors back in until they stopped, and got rejected by App Review upwards of 30 times before my first app went live.
  • Every one of these started with me knowing nothing and figuring it out.
  • OpenResponses passed App Review on the first try in January.
  • I pretty much always have an agent building something.
  • Most nights are me building because I can't not.

Get In Touch

Contact

I'm always open to connecting! Whether it's about my apps, what I used to build them, or just to chat about similar curiosities, reach out here or through the links below.

Or email me directly at Gunnarguy@me.com.