🦾 Agent! for macOS 26.4.1 or later

Agentic AI for your  Mac Desktop

Open Source alternative to Claude Code, Cursor and Open Claw

Cadence

Release Schedule

Approved pull requests are tested and implemented on corresponding weekends. Milestone releases are tied to real moments of growth. Reaching 500 stars, for example, will queue a new release. If the latest build becomes the #1 download on macos26.app, that milestone will also trigger a new release. For early adopters: as bug fixes land, pull requests are approved, and new features ship, the main branch will always reflect the latest work. This summer, updates may be a bit slower due to Family Medical Leave and limited computer access. Thanks in advance for your patience.

Backstory and the Tech behind Agent!

Agent! didn't come together overnight. It's the result of three years of building agentic AI apps, drawing on roughly a dozen projects developed along the way. Some of those were published under ANIE, Game Changer, BattleScript, XCF MCP Server and Client, D1F, and about eight original Swift Packages. The missing piece was achieving an intelligent autonomous time loop. Once achieved, I brought in the best of the best from the previous three years. The result is Agent! for macOS 26.4.1 or later.

The original goal was to build a Cursor killer. What emerged is something more interesting: an agentic AI with real legs. Agent! is only limited by your imagination. It can write code including video games like Boss-Man, https://github.com/macos26/bossman, create apps, write poetry via AppleScript within Pages, generate disk images, and attach them to GitHub releases. It can automate most tasks on your Mac. Ask it what you want in plain English or your native language and, after some initial configuration and user approvals, it will do everything it can to carry out your wish. Agent! is relentless, and aims to please.

All of Agent!'s IP is original and open source. Every Swift package dependency and the app itself were originally authored by the same person. This is a genuinely different ecosystem. Most agentic AI apps like Claude Code rely on 65 NPM packages from third parties. Agent! is 100% native, requires very little RAM, and weighs in at 35.5 uncompressed. That footprint includes Xcode automation, a Swift Syntax 6.2 package for troubleshooting native apps, Accessibility, AppleScript, AgentScript/ScriptingBridge, Safari automation, MCP Server support, and more. Out of the box.

What's New 🚀

• 🌐 OpenRouter provider: Full integration with OpenRouter's model catalog — one API key, 200+ models. Smart catalog fetches available models, protocol toggle (OpenAI/Anthropic) routes Claude models through the Anthropic protocol and everything else through OpenAI, and ClaudeService auto-routes when OpenRouter is selected.
• Apple AI as a real tool-calling agent: On-device Apple Intelligence (FoundationModels.Tool) handles UI automation requests like "take a photo using Photo Booth" locally — multi-step tool calls, zero cloud LLM tokens, falls through to the cloud LLM only on failure.
• SDEF + runtime app discovery: Bundle ID resolution is now zero-hardcoded. Apps in Agent/SDEFs/ plus every .app in /Applications, /System/Applications, ~/Applications are discovered at runtime — installing a new app extends what the agent can target with no code edit.
• Prompt caching for every OpenAI-format provider: Z.ai, OpenAI, Grok, Mistral, DeepSeek, Qwen, Gemini, BigModel, Hugging Face — cached_tokens is parsed from the response and shown in the LLM Usage panel. JSON request bodies use .sortedKeys so byte-stable prefixes actually hit the provider's cache.
• On-device token compression: Apple AI summarizes old conversation turns when context exceeds 30K tokens (Tier 1 of tieredCompact) — free, private, no API tokens consumed. Toggleable in the brain icon popover.
• Anti-hallucination prompt rule: Every system prompt now includes explicit guidance against fabricating findings from incomplete tool reads. The 10-consecutive-reads guard pushes the model toward "narrow or call done()" instead of "guess".
• Autonomous task loop, Xcode integration, AXorcist desktop automation, privileged daemon, multi-tab LLM config, Ollama pre-warming via LLMRegistry — all the previously-shipped fundamentals are still there.

Star History ⭐️

One app. Any AI. Total command over your Mac.

Agent! wires 18 LLM providers — Claude, GPT, Gemini, Grok, Mistral, DeepSeek, Qwen, Z.ai, BigModel, Hugging Face, OpenRouter, Ollama (cloud and local), vLLM, LM Studio, Codestral, Mistral Vibe, and on-device Apple Intelligence — into a native macOS app that doesn't just talk about doing things. It does them.

Watch it read your codebase, fix the bug, build the Xcode project, and commit the diff while you make coffee. Tell it to open Safari and text you the price of flights to Tokyo. Say "Agent!" from across the room and have it run your test suite by voice. Text your Mac from iMessage and get a polished answer before you reach your car.

It edits files with surgical string-replace diffs — every change one-click undoable from a Time-Machine-style rollback. It drives any Mac app through the Accessibility API — no AppleScript required. It remembers your preferences across sessions. It spawns parallel sub-agents for work that fans out. It indexes entire codebases into a portable JSONL repo-map that any LLM can consume. It runs shell commands as you, or as root via a Launch Daemon you approve exactly once.

Bring your own API key. Run it fully local on Ollama, vLLM, or LM Studio. Or run it free, forever, on Apple Intelligence. No subscription. No telemetry. No vendor lock-in. Your keys, your machine, your data.

Download it. Say what you need. Watch it happen.

Quick Start (Download)

1. Download Agent! and drag to Applications
2. Open Agent! -- it sets up everything automatically
3. Pick your AI -- Settings → choose a provider → enter API key

Quick Start (Build from Source)

1. Clone the repository:

   bashCopy code
   git clone https://github.com/macos26/agent.git
   cd Agent
   

Option A: Build with Xcode (Apple Developer account)

2. Open Agent.xcodeproj in Xcode.
3. Build and Run the Agent target.
4. Approve the Helper Tool: When prompted, authorize the privileged daemon to allow root-level command execution.

Option B: Build without an Apple Developer account

2. Run the build script (requires only Xcode Command Line Tools):

   bashCopy code
   ./build.sh              # Debug build
   ./build.sh Release      # Release build
   

3. The app lands in build/DerivedData/Build/Products/Debug/Agent!.app
4. Run it: open "build/DerivedData/Build/Products/Debug/Agent!.app"

⚠️ Without a developer account the app is ad-hoc signed. The Launch Agent/Daemon helpers won't register (SMAppService needs a team ID), but the LLM loop, all tools, accessibility, AppleScript, shell, and MCP all work.

Then:

5. Configure your AI Provider: Go to Settings and enter your API key or select a local provider like Ollama.

💡 Cheap GLM setup: GLM-5.1 runs on all four cheap providers — Ollama, Hugging Face, Z.ai, BigModel — at pennies per million tokens. New here? Start with Z.ai (fastest signup, GLM-5.1 is the default, nothing to provision). Running locally? Only GLM-4.7-Turbo (32B) fits on consumer hardware (M2/M3/M4 Mac, 64-128GB, via Ollama) — GLM-5 and GLM-5.1 are too large (~1.6TB), use them via the cloud providers above.

What Can It Do?

"Play my Workout playlist in Music" "Build the Xcode project and fix any errors" "Take a photo with Photo Booth" "Send an iMessage to Mom saying I'll be home at 6" "Open Safari and search for flights to Tokyo" "Refactor this class into smaller files" "What calendar events do I have today?"

Just type what you want. Agent! figures out how and makes it happen.

Key Features

🧠 Agentic AI Framework

Built-in autonomous task loop that reasons, executes, and self-corrects. Agent! doesn't just run code; it observes the results, debugs errors, and iterates until the task is complete.

🛠 Agentic Coding

Full coding environment built in. Reads codebases, edits files with precision, runs shell commands, builds Xcode projects, manages git, and auto-enables coding mode to focus the AI on development tools. Replaces Claude Code, Cursor, and Cline -- no terminal, no IDE plugins, no monthly fee. Features Time Machine-style backups for every file change, letting you revert any edit instantly.

🔍 Dynamic Tool Discovery

Automatically detects and uses available tools (Xcode, Playwright, Shell, etc.) based on your prompt. No manual configuration required for core tools.

🛡 Privileged Execution

Securely runs root-level commands via a dedicated macOS Launch Daemon. The user approves the daemon once, then the agent can execute commands autonomously via XPC.

Why there's no manual setCodeSigningRequirement on the XPC listener

Users sometimes ask why AgentHelper's XPC listener accepts connections without a manual connection.setCodeSigningRequirement(...) check. The short answer: SMAppService already enforces signing identity one layer below your code, so the check would be redundant.

That recommendation is a holdover from the pre-SMAppService SMJobBless era, where launchd did not validate identity for you and the XPC server had to set a designated-requirement string itself. SMAppService changed that contract:

• The app-bundle-embedded plist plus signature-gated registration is the code-signing requirement.
• The Mach service names (Agent.app.toddbruss.helper, Agent.app.toddbruss.user) are namespaced to the signed bundle that registered them — no other bundle can claim them.
• Any signature mismatch (tampering, re-signing, different Team ID, bundle swap) breaks the XPC channel at the launchd layer — listener(_:shouldAcceptNewConnection:) is never even invoked.

Empirical proof: Agent! itself attempted to re-sign its own daemons during an experiment and immediately lost the ability to connect. NSXPCConnection to both Mach services failed at the launchd layer before a single byte reached the listener delegate — exactly the behavior a manual setCodeSigningRequirement call would enforce, except SMAppService is doing it in the kernel's XPC lookup path where it cannot be bypassed from userland.

Adding setCodeSigningRequirement explicitly would be reasonable belt-and-braces defense-in-depth (useful only if the app were ever ported off SMAppService, or if SIP were disabled), but it is not a gap in the current architecture. See docs/SECURITY.md for the full trust-anchor write-up.

🖥 Desktop Automation (AXorcist)

Control any Mac app through the Accessibility API. Click buttons, type into fields, navigate menus, scroll, drag -- all programmatically. Powered by AXorcist for reliable, fuzzy-matched element finding.

🤖 18 AI Providers

The provider picker (LLM Settings, toolbar button #7) shows 17 providers; Apple Intelligence is reached via the separate brain icon (#8). Source of truth: AgentTools.APIProvider.

💡 Self-hosted "free" providers (Local Ollama, vLLM, LM Studio) are only free in the API-fee sense. Running a 30B+ model with usable speed needs an M2/M3/M4 Ultra Mac Studio (64-128GB unified memory) or a Linux box with 24GB+ VRAM. If you don't already have that hardware, the cloud paths above (Ollama Cloud, Hugging Face, Z.ai, BigModel, DeepSeek) are dramatically cheaper than buying it.

Toolbar Buttons

The Agent! header contains 15 buttons for quick access to settings, monitors, and tools. Each button opens a popover when clicked. Source of truth: Agent/Views/HeaderSectionView.swift.

🎙 Voice Control — "Agent!" Hotword

Hotword-anchored dictation via SFSpeechRecognizer. Click the microphone in the input bar to start the hotword session, then say "Agent!" followed by your task. Transcription is on-device, runs in real time, and listens for agent as a complete word (not as a substring of "intelligent" or "management"). Anything you say after the wake word becomes the task — after ~2.5 seconds of silence, it auto-runs. The session loops automatically: when one task completes, it starts listening again. Click the mic to stop.

📱 Remote Control via iMessage

Text your Mac from your iPhone:

Copy code
Agent! What song is playing?
Agent! Check my email
Agent! Next Song

Your Mac runs the task and texts back the result. Only approved contacts can send commands.

🌐 Web Automation

Drives Safari hands-free -- search Google, click links, fill forms, read pages, extract information.

📋 Smart Planning

For complex tasks, Agent! creates a step-by-step plan, works through each step, and checks them off in real time.

🗂 Tabs

Work on multiple tasks simultaneously. Each tab has its own project folder and conversation history.

📸 Screenshot & Vision

Take screenshots or paste images. Vision-capable AI models analyze what they see -- describe content, read text, spot UI issues.

🌐 Safari Web Automation (Built-in)

Agent! includes built-in Safari web automation via JavaScript and AppleScript. Search Google, click links, fill forms, read page content, and execute JavaScript -- all hands-free.

To enable: Open Safari → Settings → Advanced → check "Show features for web developers". Then go to Developer menu → check "Allow JavaScript from Apple Events".

🎭 Playwright Web Automation (Optional)

Full cross-browser automation via Microsoft Playwright MCP. Click, type, screenshot, and navigate any website in Chrome, Firefox, or WebKit -- all controlled by the AI.

Setup (one-time):

bashCopy code
# 1. Install Node.js (if not already installed)
brew install node

# 2. Install Playwright MCP server globally
npm install -g @playwright/mcp@latest

# 3. Install browser binaries (pick one or all)
npx playwright install chromium          # Chrome (~165MB)
npx playwright install firefox           # Firefox (~97MB)
npx playwright install webkit            # Safari/WebKit (~75MB)
npx playwright install                   # All browsers

Configure in Agent!:

Go to Settings → MCP Servers → Add Server, paste this JSON:

jsonCopy code
{
    "mcpServers": {
        "playwright": {
            "command": "npx",
            "args": ["@playwright/mcp"],
            "transport": "stdio"
        }
    }
}

Note: If npx is not found, use the full path: run which npx in Terminal and replace "npx" with the result (e.g. "/opt/homebrew/bin/npx").

Toggle ON and Playwright tools appear automatically. The AI can now control browsers directly.

Tools — what list_tools actually returns

These are the canonical tool names defined in AgentTools.Name.* and exposed to every LLM provider via AgentTools.tools(for:). Source of truth: ~/Documents/GitHub/AgentTools/Sources/AgentTools/AgentTools.swift. The Agent app's user-pref toggles can hide individual tools per-provider, but the list below is the full set the LLM ever sees.

Core / discovery

Code / files / build

Shell / privilege tiers

macOS automation

Web automation

Sub-agents

💡 Note: The on-device app filters this list per-provider — toggle individual tools in the Tools popover (button #6 in the toolbar above). Apple Intelligence has its own minimal default set because of its small context window. MCP tools are appended at runtime as mcp_<server>_<tool> and listed under "--- MCP Tools ---" by list_tools.

Privacy & Safety

• Your data stays on your Mac. Files, screen contents, and personal data are never uploaded.
• Cloud AI only sees your prompt text. Use local AI to stay 100% offline.
• You're in control. Agent! shows everything it does and logs every action.
• Built on Apple's security model. macOS permissions protect your system.

Defense Layers

Keyboard Shortcuts

Source of truth: the TextField .onSubmit in Agent/Views/InputSectionView.swift for Return, and the inline NSEvent.addLocalMonitorForEvents block in Agent/Views/ContentView.swift for everything else.

Slash Commands

Type these in the input field and press Return — they execute locally without going to any LLM. Source of truth: AgentViewModel+RunStop.swift.

FAQ

Do I need to know how to code? No. Just type what you want in plain English.

Is it safe? Yes. Standard macOS automation, full activity logging, you approve permissions.

How much does it cost? The Agent! app itself is free (MIT License). Cloud AI providers charge for API usage — the cheapest options for serious work are GLM-5/5.1 via Z.ai, BigModel, or Hugging Face (pennies per million tokens), or DeepSeek for budget coding. Self-hosted local models (Ollama, vLLM, LM Studio) have no API fees but only make sense if you already own the hardware to run them — see the hardware note below.

What Mac do I need? macOS 26.4.1. Apple Silicon required. For cloud providers, any modern Mac works fine. For self-hosted local models (Ollama, vLLM, LM Studio): a 7B model fits in 16GB unified memory, a 13B model in 24GB, a 30B model needs 64GB+ (M2/M3/M4 Ultra Mac Studio territory). Apple Intelligence (the on-device mediator for triage / accessibility intent / token compression) needs an Apple Silicon Mac with Apple Intelligence enabled in System Settings.

How is this different from Siri? Siri answers questions. Agent! performs actions -- controls apps, manages files, builds code, automates workflows.

Documentation

• Technical Architecture -- Tools, scripting, developer details
• Comparisons -- vs Claude Code, Cursor, Cline, OpenClaw
• Security Model -- XPC architecture, privilege separation
• FAQ -- Common questions

Built-in Xcode Tools

Agent! includes native Xcode integration that works without any MCP server setup. These built-in tools are often faster and more reliable than the MCP alternative since they run directly inside the app.

Just say "bump version" and Agent! reads the current version, asks major/minor/patch, updates Info.plist and project settings, builds to verify, and commits the change. No manual plist editing, no missed build numbers.

The AI automatically uses these when you ask it to build, fix errors, or work with Xcode projects. No configuration needed -- just have your project open in Xcode.

🚀 iOS/iPadOS Support: Coming soon! Native support for building, running, and testing iOS and iPadOS apps directly from Agent! is in development.

Tip: For most coding workflows, the built-in tools are all you need. The MCP Xcode server below adds extras like SwiftUI Preview rendering and documentation search.

Two ways to talk to Agent! — voice and iMessage

Both features use the same wake word: "Agent!" (case-insensitive — Agent!, agent!, AGENT!, even just Agent or agent all work).

🎤 Voice (dictation hotword)

Click the microphone in the input bar and start the hotword session, then speak. Agent! transcribes in real time using SFSpeechRecognizer and listens for the word "agent" as a complete word (not as a substring of "intelligent" or "management"). Anything you say after "agent" becomes the task. After ~2.5 seconds of silence, the task auto-runs.

Examples:

• "Agent, what song is playing?"
• "Agent take a screenshot of Safari"
• "Agent build the Xcode project"

The hotword session loops automatically — after one task completes, it goes back to listening. Click the mic again to stop.

📱 iMessage (remote control)

Text your Mac from your iPhone. Agent! polls ~/Library/Messages/chat.db every 5 seconds for new messages and reacts to anything starting with Agent! (case-insensitive, exclamation mark optional).

Examples:

Copy code
Agent! What song is playing?
agent! check my email
AGENT! next song
Agent  open Safari

Agent! sends an immediate "Working on it..." acknowledgment, runs the task on a dedicated Messages tab using your main tab's LLM config, and then texts the result back to you.

Setup (one-time):

1. Grant Full Disk Access — System Settings → Privacy & Security → Full Disk Access → enable Agent! (required to read chat.db directly via SQLite)
2. Open the Messages Monitor — toolbar button #2 (chat bubble icon, turns green when on)
3. Approve a sender — once a message arrives from a new contact, that contact appears in the recipients list. Toggle them on to approve.

Only approved senders can run tasks. Unapproved messages are logged but ignored. Your reply is sent back via AppleScript to the same handle that sent the command, capped at 4000 characters.

Outgoing replies have any leading "Agent!" stripped so the receiving Mac doesn't trigger its own command loop.

Agent! supports MCP servers for extended capabilities. Configure in Settings → MCP Servers.

Xcode MCP Server

Connect Agent! directly to Xcode for project-aware operations:

jsonCopy code
{
  "mcpServers" : {
    "xcode" : {
      "command" : "xcrun",
      "args" : [
        "mcpbridge"
      ],
      "transport" : "stdio"
    }
  }
}

Xcode MCP provides:

• Project-aware file operations (read/write/edit/delete)
• Build and test integration
• SwiftUI Preview rendering
• Code snippet execution
• Apple Developer Documentation search
• Real-time issue tracking

License

MIT - free and open source.

Agent! for macOS 26.4.1 - Agentic AI for your  Mac Desktop

Note: Claude refers to the Anthropic AI model integrated into Agent! for LLM functionality. It is not a human contributor Agent!

Agent! vs Claude Code — Architectural Comparison

Agent! is a 100% original pure Swift macOS application. It is not a port, fork, or derivative of any other project.

⚠️ Legal Notice & Attribution

Trademark Notice

"🦾 Agent! for macOS26" is an independent software project and is not affiliated with, endorsed by, sponsored by, or otherwise associated with Apple Inc. "Apple," "Mac," "Mac mini," "MacBook," "macOS," and related marks are trademarks of Apple Inc., registered in the U.S. and other countries. All other trademarks, service marks, and trade names referenced herein are the property of their respective owners and are used for identification purposes only.

"🦾 Agent!" and the 🦾 Agent! logo are trademarks of Todd Bruss. Use of these marks requires prior written permission. The MIT license below grants rights to the source code only — it does not grant any trademark rights.

Source Code License (MIT)

The source code of "🦾 Agent! for macOS26" is open source and licensed under the MIT License. You are free to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the source code, subject to the conditions in the LICENSE file (retain copyright notice and the MIT permission notice in all copies or substantial portions of the software).

Compiled Binaries & Releases

Compiled binaries, installers, code-signed builds, and release artifacts distributed through this project's GitHub Releases, agent.macOS26.app, or any other official channel are the copyrighted work of Todd Bruss and are not covered by the MIT license that governs the source code. All rights to the official binaries — including the "🦾 Agent!" name, logo, code-signing identity, and Developer ID — are reserved.

Copyright © 2000, 2023–2026 Todd Bruss, All Rights Reserved.

You are welcome to build your own binaries from source under the MIT license, provided you do not use the "🦾 Agent!" name, logo, or branding to identify your product.

Warranty Disclaimer

This software is provided "AS IS," without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the author or copyright holder be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.

---

Thank you for your interest in 🦾 Agent! — an application crafted for Mac mini, MacBook, and Mac desktop computers running macOS 26.4 or later on genuine Mac hardware and software.

Sincerely, Todd Bruss Forward Deployed Engineer, 🦾 Agent! for macOS 26.4.1 https://agent.macOS26.app https://github.com/macos26/agent