> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Noodle: The Multi-Agent macOS App That Treats AI Subscriptions as Shareable Infrastructure

[ View on GitHub ]

Noodle: The Multi-Agent macOS App That Treats AI Subscriptions as Shareable Infrastructure

Hook

What if you could lend your Claude API subscription to your spouse without sharing credentials, the same way you share a Netflix account? Noodle makes AI service accounts infrastructure instead of identity.

Context

Every major AI chat interface today tightly couples three concerns that should be separate: your authentication credentials, the conversation history, and the execution environment where agents run. When you use ChatGPT's desktop app, switching from GPT-4 to Claude means starting over in a different application with zero context transfer. Sharing your API access with a family member requires handing over credentials that grant full billing control. And every agent interaction happens in a cloud sandbox where you have no visibility into what's persisted or how your data is used.

Noodle reimagines this architecture with a radical premise: AI service accounts should work like home infrastructure. You authenticate once with OpenAI, Anthropic, or xAI, then create multiple 'harnesses' (agent configurations) that can use those credentials without re-authentication. Each harness maintains its own conversation history, tool access, and execution context locally on your Mac. The Hub component extends this further—a 'lending' Mac can share authenticated harness access to other devices on your network, letting family members run agents using your subscriptions while you maintain billing control. All state lives in local SQLite databases and filesystem stores, not vendor servers. For developers tired of cloud-native agent platforms that treat your conversations as training data and your execution as metered compute, Noodle offers a local-first alternative that trades horizontal scalability for data sovereignty.

Technical Insight

Execution Contexts

User Input

Load Config

API Calls

Responses

Tool Requests

macOS APIs

OCR/Shell/Files

Route to

Route to

Route to

Results

Update State

Render

Share Harness Access

Execute via Host

SwiftUI Chat Interface

Harness Manager

SQLite Config Store

AI Protocol Bridge

Workspace Router

MCP Tool System

Hub Server

Credential Sharing

AI Providers

OpenAI/Anthropic/xAI

Local Sandbox

Noodle Computer

Dedicated VM

Noodle Browser

WKWebView Profile

Remote Client Device

System architecture — auto-generated

Noodle's core architectural insight is the harness abstraction layer. A harness isn't just a chat thread—it's a complete execution context that binds an AI model provider to persistent state, tool access permissions, and optional dedicated compute resources. The implementation separates these concerns into distinct Swift processes communicating through XPC (cross-process communication).

Here's how harness configuration works in practice:

// Harness configuration stored in local SQLite
struct HarnessConfig: Codable {
    let id: UUID
    let name: String
    let providerType: AIProvider // .openai, .anthropic, .xai
    let modelIdentifier: String
    let toolPermissions: [MCPToolAccess]
    let workspaceType: WorkspaceType // .local, .computer, .browser
    let voiceEnabled: Bool
}

enum WorkspaceType {
    case local // Standard filesystem sandbox
    case computer(userId: String) // Dedicated macOS user account
    case browser(profilePath: URL) // Persistent WKWebView profile
}

The genius is that switching a harness from Claude to GPT-4 is just mutating providerType and modelIdentifier—conversation history, tool permissions, and workspace state remain intact. This is architecturally superior to systems where agents are model-specific entities that can't be migrated.

The Hub's credential-sharing mechanism uses localhost-based multi-tenancy. When you enable Hub mode, Noodle starts a local server that accepts connections from authenticated client devices. Remote clients send agent queries to your Hub, which proxies requests to AI providers using your stored credentials, then streams responses back:

// Simplified Hub routing logic
class HubRouter {
    private let harnessStore: HarnessStore
    private let credentialVault: KeychainCredentialStore
    
    func handleRemoteQuery(
        clientId: UUID,
        harnessId: UUID, 
        message: String
    ) async throws -> AsyncStream<String> {
        // Client never sees credentials
        guard let harness = harnessStore.load(harnessId) else {
            throw HubError.harnessNotFound
        }
        
        let credentials = try credentialVault.retrieve(
            for: harness.providerType
        )
        
        // Execute on Hub's hardware, stream to client
        return try await AIProviderFactory
            .create(harness.providerType, credentials: credentials)
            .stream(message: message, context: harness.conversationHistory)
    }
}

Clients maintain their own UI and conversation state, but all API calls route through the Hub host. This solves the 'I want to try Claude but don't want to pay' problem without credential exposure—you control rate limits and can revoke access by removing the client device from your Hub's allow list.

The Noodle Computer workspace type is particularly clever infrastructure. Instead of spinning up Docker containers or VMs, it leverages macOS's built-in multi-user architecture:

# Noodle creates dedicated user accounts for agent isolation
sudo dscl . -create /Users/noodle-agent-001
sudo dscl . -create /Users/noodle-agent-001 UserShell /bin/zsh
sudo dscl . -create /Users/noodle-agent-001 NFSHomeDirectory /Users/noodle-agent-001

# Agent file operations execute as that user
su noodle-agent-001 -c "python3 /path/to/agent-script.py"

This gives agents true OS-level isolation with separate home directories, but avoids VM licensing costs and hypervisor overhead. File operations, network access, and process spawning all happen in a real macOS environment with standard UNIX permissions enforcing sandboxing. It's essentially treating user accounts as lightweight containers.

Tool integration uses the Model Context Protocol (MCP), but with native Swift implementations instead of network-proxied services. The OCR tool demonstrates this pattern:

// MCP tool running as local Swift process
struct OCRTool: MCPTool {
    let identifier = "vision.ocr"
    
    func execute(parameters: [String: Any]) async throws -> MCPToolResult {
        guard let imagePath = parameters["image_path"] as? String else {
            throw MCPError.missingParameter("image_path")
        }
        
        // Use Apple's Vision framework - zero network calls
        let request = VNRecognizeTextRequest()
        request.recognitionLevel = .accurate
        request.usesLanguageCorrection = true
        
        let handler = VNImageRequestHandler(
            url: URL(fileURLWithPath: imagePath)
        )
        try handler.perform([request])
        
        let recognizedText = request.results?
            .compactMap { $0.topCandidates(1).first?.string }
            .joined(separator: "\n") ?? ""
        
        return MCPToolResult(output: recognizedText, metadata: [:])
    }
}

This local-first approach means OCR operations have zero latency and never send image data off-device. The agent gets instant results without API round-trips, and users avoid privacy concerns inherent in cloud-based vision services. MCP provides the abstraction layer so agents invoke tools uniformly, while Swift implementations leverage native macOS frameworks unavailable to cloud services.

Gotcha

The macOS 26 minimum requirement is an immediate dealbreaker for anyone wanting to use this today. As of early 2025, macOS 26 hasn't shipped to stable, meaning Noodle is relying on beta APIs that may change or unreleased SwiftUI features. This suggests either premature open-sourcing or dependence on Apple frameworks not yet finalized. You cannot evaluate this tool in production until mid-2025 at earliest.

The Swift-only implementation creates a hard barrier to ecosystem integration. Python dominates AI development—LangChain, Transformers, the entire Hugging Face ecosystem, and most custom model tooling exists in Python. While MCP theoretically bridges this gap, writing custom tools requires Swift proficiency. If your workflow involves LangChain agents, Python-based RAG pipelines, or fine-tuned models with Python inference code, Noodle offers no integration path. The browser automation feature also has fundamental limitations: modern web apps with strict Content Security Policies or anti-bot detection will break WKWebView inspection. Agents can't reliably automate Google Workspace, modern banking sites, or most SaaS dashboards that actively block programmatic access. Finally, the comparison table positioning Noodle against 'Grok Bot' and 'Muse' (both obscure or non-existent projects) while ignoring LangChain, AutoGPT, and Rivet suggests the author hasn't benchmarked against real alternatives.

Verdict

Use Noodle if you're a privacy-conscious Mac user who already maintains multiple AI subscriptions (OpenAI, Anthropic, xAI) and wants agent persistence that survives across model providers without vendor lock-in. The Hub credential-sharing model is legitimately innovative for families or small teams wanting to share API access without security risks. If you need agents with real macOS file system permissions, on-device tool execution for privacy, or want to experiment with multi-agent orchestration in a native Swift environment, this is the only open-source tool with that architecture. Skip entirely if you require production stability before macOS 26 ships, need cross-platform support (Linux/Windows), want integration with Python AI frameworks, or expect reliable browser automation against modern web applications. This is sophisticated personal infrastructure for advanced Mac users, not enterprise-ready agent tooling.