Swarm

Build production AI agents in Swift.

Swarm is a Swift-native agent runtime for type-safe tools, on-device Apple Foundation Models, composable workflows, memory, guardrails, and streaming. Build for iOS, macOS, and Linux with the same agent loop.

Get started · Browse examples · ⭐ Star on GitHub

import Swarm

@Tool("Looks up a stock price")
struct PriceTool {
    @Parameter("Ticker symbol") var ticker: String

    func execute() async throws -> String {
        "AAPL: $182.50"
    }
}

let agent = try Agent(
    "Answer finance questions using available tools.",
    configuration: .default.name("Analyst"),
    inferenceProvider: .foundationModels()
) {
    PriceTool()
}

let result = try await agent.run("What is AAPL trading at?")
print(result.output)

The example uses Apple Foundation Models on supported devices. Use an OpenAI-compatible provider, Ollama, a mock provider, or the deterministic examples when Foundation Models is unavailable.

Install

Add Swarm with Swift Package Manager:

dependencies: [
    .package(
        url: "https://github.com/christopherkarani/Swarm.git",
        from: "0.6.6"
    )
]

The default package is lean: core Swarm, Foundation Models, and macros. Lean resolve pins swift-syntax (via the default-on Macros trait) and swift-log only — not the MCP Swift SDK or OpenTelemetry. Add traits for optional surfaces:

// Durable graph, ContextCore/Wax memory, Membrane, web helpers
.package(
    url: "https://github.com/christopherkarani/Swarm.git",
    from: "0.6.6",
    traits: ["Integrations"]
)

// MCP server adapter (SwarmMCP + MCP Swift SDK). Also enables Macros.
.package(
    url: "https://github.com/christopherkarani/Swarm.git",
    from: "0.6.6",
    traits: ["MCP"]
)

// OpenTelemetry wrappers (SwarmOpenTelemetry). Also enables Macros.
.package(
    url: "https://github.com/christopherkarani/Swarm.git",
    from: "0.6.6",
    traits: ["OpenTelemetry"]
)

Macros are enabled by default. If you want a macro-free build, use traits: [] and define tools with FunctionTool. Specifying traits replaces defaults, so combine as needed — for example traits: ["Integrations", "MCP", "OpenTelemetry"].

Why Swarm

Swarm uses Swift 6.2 strict concurrency, so values crossing actor boundaries must pass compiler checks.

Apple Foundation Models gives supported devices an on-device inference path. When you need a local HTTP model or a cloud API, the same agent loop works with Ollama, LM Studio, OpenAI-compatible providers, or your own provider.

The @Tool macro generates tool schemas from Swift types at compile time. FunctionTool is available when you do not want macros.

Workflow lets you chain, parallelize, route, repeat, and time out agent work. Job is the other composition tool: a shared notes box and helpers that each get their own brief, including when you only know how many helpers you need after an earlier step.

Add memory, guardrails, retries, fallbacks, streaming, tracing, MCP, and optional checkpoint/resume as your application grows.

Build a workflow

Agents compose into sequential, parallel, and routed workflows:

let researcher = try Agent(
    "Research the topic and extract key facts.",
    inferenceProvider: .foundationModels()
)

let writer = try Agent(
    "Write a concise summary from the research.",
    inferenceProvider: .foundationModels()
)

let result = try await Workflow()
    .step(researcher)
    .step(writer)
    .run("Latest advances in on-device ML")

For fan-out and routing:

let result = try await Workflow()
    .parallel([bullAgent, bearAgent, analystAgent], merge: .structured)
    .run("Evaluate Apple's Q4 earnings.")

let routed = try await Workflow()
    .route { input in
        input.contains("$") ? mathAgent : generalAgent
    }
    .run("What is 15% of $240?")

Providers

Every agent uses a pluggable InferenceProvider. The agent loop stays the same when you change models or deployment environments. Set a process-wide default with await Swarm.configure(provider:) when you do not want to pass a provider on every agent.

let local = try Agent(
    "Be helpful.",
    inferenceProvider: .openAICompatible(.ollama(model: "llama3.2"))
)

See Remote Providers for configuration and privacy details.

Examples

Copy a complete example, or run one in deterministic demo mode without API keys or Apple Intelligence:

cd Examples/OnDeviceChat
swift run OnDeviceChat --demo

More capabilities

Requirements

Foundation Models and some platform integrations are Apple-only. The Integrations memory/Membrane stack builds on Linux with portable CPU/hash backends (Metal/CoreML/MetalANNS accelerate on Apple). The default Swarm graph is CI-tested on Ubuntu with Swift 6.2. Apple-only features such as Foundation Models, SwiftData, OSLog, and some built-in tool behavior are unavailable or different on Linux; use an OpenAI-compatible provider, inject a mock, or run the deterministic examples.

To configure one provider globally for the default graph:

await Swarm.configure(provider: myProvider)

Documentation

Contributing

./scripts/ci/lean-build-test.sh
swiftformat Sources Tests --lint --config .swiftformat

All public types are expected to be Sendable. Bug reports and feature requests belong in GitHub Issues.

If Swarm helps you ship, star the repository and share what you built.

Community and license

Discussions · @ckarani7 · MIT License