An agent that lives on your phone.¶
loopl runs the model, the loop and the tools on the device. It talks, uses the phone, asks before it acts — and works with the network off.
Public beta · nothing collected · works in airplane mode
- Offline
- Native tools
- Asks first
- Your own model
- Open SDK

Six things the app does. All on the phone.
Pick a model. Download once.
Qwen, Gemma, Llama, DeepSeek — or Apple's built-in model with nothing to download. Your own private Hugging Face repos too.
Talk to it. Even in airplane mode.
Tokens stream on the GPU. One switch refuses every network call; the agent keeps working.
It uses the phone.
Torch, haptics, offline translation, speech, image generation, other apps. Every call is a row you can expand.
It asks before it acts.
Anything that leaves the device — a request, another app — waits for your tap. Deny, and the model is told so.
Show it. Tell it.
Send a photo to a vision model. Record a take and let it transcribe.
Train it on your own conversations.
Pick chats, push them to your private dataset, start a fine-tune on Hugging Face, download the result. From the phone.
The same loop, in Swift.
loopl is a Swift SDK first; the app is its showcase. Model, tools, model — until it's done. That is the whole algorithm. The model streams; if it asks for tools they run, their results go back, and it is called again. There is no iteration cap — the context window and your Stop button are the only bounds.
-
StreamText arrives token by token; tool calls are parsed from whatever dialect the model speaks.
-
Run toolsEvery call in a turn runs concurrently. Calls are checked against each tool's schema first, so a malformed call becomes an error the model can read and fix.
-
RepeatResults go back to the model. When it stops calling tools, you get the answer, the metrics and the full history.
The phone is the toolbox.
Image generation, the torch, haptics, other apps, offline translation and speech ship with the SDK — and they are only the starting point.
generate_imageA picture from a prompt, via Image Playground.
open_appasks firstOpens another app with a deep link, passing context along.
flashlightTorch on, off or dimmed.
vibrateHaptic patterns: tap, success, heartbeat…
generate_voiceSpeaks with on-device voices, Personal Voice included.
transcribeSpeech to text, offline — record a take in the composer.
translateApple's offline translation packs.
describe_imageScene labels, faces, barcodes — Vision.
remember · recallNotes the agent keeps between chats.
httpasks firstAny HTTPS request, behind a human approval card.
calculator · current_timeExact arithmetic, any time zone.
your_toolA Swift struct: name, schema, async function. ↓
A tool is a Swift struct.
A name, a description, a JSON schema and an async function. Hand it to an Agent next to the built-ins.
- Typed, actor-safe. Swift 6 concurrency, async streams all the way down.
- Human in the loop. Any tool can ask before it acts; the approval card is a SwiftUI view.
- Structured output. Ask for a Decodable, get one back.
- Hooks, checkpoints, tracing. When you need them, not before.
import Loopl
struct Battery: Tool {
let name = "battery_level"
let description = "Battery level, in percent."
let parameters = ToolSchema.object([:])
func call(_ args: [String: JSONValue]) async throws -> String {
"87 %"
}
}
func ask(_ model: any Model) async throws -> String {
let agent = Agent(model: model, tools: [Battery()])
let result = try await agent("Do I need to charge?")
return result.text
}
Three engines. One protocol.
MLX on the GPU, llama.cpp for GGUF, or Apple's built-in model. Swap the engine, keep the agent. Any public Hugging Face repo loads the same way.
iPhone 16 Pro
iPhone 16 Pro
iOS 26 · nothing to download
Single runs from the app's self-test, not averages. All models →
Download it. Turn the network off. Ask it something.¶
Free · iOS 18+ · open source · nothing collected





