Bringing fmsg to iOS, and letting agents talk to each other

A messaging platform for people, businesses and AI agents

Three things make this harder than a chat app

Researcher, designer and engineer on one deadline

From application to agent-to-agent demo

public nonisolated func events() -> AsyncStream<FmsgEvent> {
    AsyncStream { continuation in
        let task = Task {
            let decoder = FmsgClient.makeDecoder()
            var backoff: UInt64 = 1
            while !Task.isCancelled {
                var socket: URLSessionWebSocketTask?
                do {
                    let ws = try await self.openSocket()   // fresh JWT on every connect
                    socket = ws
                    continuation.yield(.connected)          // caller catches up from the inbox
                    while !Task.isCancelled {
                        let data: Data
                        switch try await ws.receive() {
                        case .string(let text): data = Data(text.utf8)
                        case .data(let bytes): data = bytes
                        @unknown default: continue
                        }
                        backoff = 1
                        if let event = Self.decodeEvent(data, decoder) { continuation.yield(event) }
                    }
                } catch {
                    socket?.cancel(with: .goingAway, reason: nil)
                    continuation.yield(.disconnected(error.localizedDescription))
                    try? await Task.sleep(nanoseconds: backoff * 1_000_000_000)
                    backoff = min(backoff * 2, 60)
                }
            }
            continuation.finish()
        }
        continuation.onTermination = { _ in task.cancel() }
    }
}

for await event in fmsg.events() {
    switch event {
    case .connected:
        // Inbox is newest first; answer the oldest unread first.
        for message in try await fmsg.inbox().reversed() where message.read != true {
            await handle(message)
        }
    case .newMessage(let message):
        await handle(message)
    case .disconnected, .updated:
        break
    }
}

private func handle(_ message: FmsgMessage) async {
    guard !handled.contains(message.id),            // already seen via the other path
          !sameAddress(message.from, me.address),   // our own reply echoing back
          !message.isReaction,                      // emoji reactions are messages too
          message.acceptsReplies else { return }     // sender set no_reply or terminal
    handled.insert(message.id)
    // … read thread, reply, mark read. On failure: handled.remove(id) so catch-up retries.
}

Why marking read matters

One line of conversation, with every branch one swipe away

private func conversation(_ thread: FmsgThread) -> [Claude.Message] {
    var turns: [Claude.Message] = thread.messages.map { m in
        guard m.visible else { return .init(role: "user", content: "[earlier message not visible to you]") }
        var text = m.body?.text ?? "[non-text message: \(m.body?.type ?? "unknown")]"
        let files = (m.attachments ?? []).compactMap(\.filename)
        if !files.isEmpty { text += "\n[attachments: \(files.joined(separator: ", "))]" }
        if let from = m.from, sameAddress(from, me.address) { return .init(role: "assistant", content: text) }
        return .init(role: "user", content: "\(m.from ?? "unknown"):\n\(text)")
    }
    if turns.first?.role != "user" { turns.insert(.init(role: "user", content: "[thread start]"), at: 0) }
    return turns
}

Reply-all that respects sub-addresses, and a hard cap per thread

public func reply(to parent: FmsgMessage, text: String) async throws -> Int {
    let me = try await whoami()
    var recipients = parent.participants          // from + to + add_to batches
    if let owner = me.owner { recipients.append(owner) }
    let to = uniqueAddresses(recipients.filter { !sameAddress($0, me.address) })
    return try await send(NewMessage(from: me.address, to: to, pid: parent.id, data: text))
}

let root = thread.rootId ?? message.id
guard repliesByThread[root, default: 0] < maxRepliesPerThread else {
    print("  reply limit reached for thread #\(root); not answering")
    try await fmsg.markRead(message.id)
    return
}

A native iOS app, not a shrunk website

What the client got before signing anything

Week one of the contract, already de-risked

Show, then tell