MCP server

Axint ships an MCP (Model Context Protocol) server alongside the CLI. Any AI assistant that speaks MCP can call Axint directly to scaffold, compile, validate, and browse templates without leaving the editor.

Supported integrations

Claude Code

Add via claude mcp add
~/.config/claude-code/mcp.json
Open setup guide →

Claude Desktop

Paste MCP JSON config
~/Library/Application Support/Claude/claude_desktop_config.json
Open setup guide →

Cursor

Open Cursor deeplink
~/Library/Application Support/Cursor/User/mcp.json
Open setup guide →

Codex

Add via codex mcp add
~/.codex/config.toml
Open setup guide →

VS Code

Open VS Code deeplink
.vscode/mcp.json
Open setup guide →

Windsurf

Open Windsurf deeplink
~/.codeium/windsurf/mcp_config.json
Open setup guide →

Xcode

Run axint xcode setup
xcrun mcpbridge + your agent MCP config
Open setup guide →

Also supported

JetBrains

Paste MCP JSON config
Settings → Tools → AI Assistant → MCP Servers

Neovim

Use stdio command in your MCP plugin
Your MCP plugin config

Examples repo

Real install-ready starter projects live in axint-examples. Use it when you want a working repo instead of a bare command snippet.

Legacy package migration

Old package names like @axintai/compiler and axintai are deprecated. The current package names are @axint/compiler and axint.

Available tools

Tool	What it does
`axint.status`	Report the running MCP server version, package path, uptime, and same-thread reload/update steps
`axint.upgrade`	Check or apply an Axint package upgrade and return a same-thread continuation prompt
`axint.doctor`	Audit version truth, Node/npm/npx paths, project MCP wiring, and project start files
`axint.xcode.guard`	Return the Xcode-specific guardrail for proving SwiftUI, build, and UI-test repairs before claiming success
`axint.xcode.write`	Write Xcode-safe files with guard metadata when an agent is allowed to touch Apple project sources
`axint.session.start`	Start an enforced Axint session, write `.axint/session/current.json`, and return the token used by workflow gates
`axint.feature`	Generate a complete Apple-native feature package from a description
`axint.project.pack`	Generate `.mcp.json`, `AGENTS.md`, `CLAUDE.md`, and `.axint` project-start files
`axint.project.index`	Index changed and related project files so repair, Cloud Check, and context tools can reason with nearby code
`axint.context.memory`	Return compact operating memory after a new chat or context compaction
`axint.context.docs`	Return the docs context agents should reload after compaction
`axint.suggest`	Suggest Apple-native features for an app domain
`axint.registry.search`	Search public Registry packages before regenerating code from scratch
`axint.workflow.check`	Gate planning, writing, building, and committing against the active Axint session and evidence
`axint.scaffold`	Generate a complete starter intent from a name, description, domain, and parameter list
`axint.compile`	Compile a TypeScript intent source string to Swift (+ optional Info.plist / entitlements fragments)
`axint.validate`	Parse + validate without generating Swift
`axint.fix-packet`	Read the latest local Fix Packet or repair prompt
`axint.cloud.check`	Run Cloud Check from the agent loop and return report, prompt, JSON, or feedback signal
`axint.repair`	Plan a project-aware repair for existing Apple app bugs, including likely files, root causes, host-aware patch guidance, proof commands, and privacy-safe feedback
`axint.feedback.create`	Create or read a source-free feedback packet that users can inspect before sending to Axint Cloud
`axint.agent.install`	Install the local multi-agent project brain, project context, file-claim ledger, and privacy defaults
`axint.agent.advice`	Return host-specific next moves from project context, active claims, latest proof, and latest repair artifacts
`axint.agent.claim`	Claim files before an agent edits them so parallel agents do not patch the same surface at the same time
`axint.agent.release`	Release local file claims when an agent finishes, abandons, or hands off the task
`axint.run`	Run the enforced Apple proof loop across session recovery, Swift validation, Cloud Check, xcodebuild, tests, and runtime proof
`axint.run.status`	Rejoin or inspect an active Axint run when a host disconnects or a long proof loop keeps running
`axint.run.cancel`	Stop an active Axint run and its child process group
`axint.tokens.ingest`	Convert design tokens into SwiftUI token enums for generated views
`axint.schema.compile`	Compile a minimal JSON schema directly to Swift
`axint.swift.validate`	Validate existing Swift sources against build-time rules
`axint.swift.fix`	Auto-fix mechanical Swift validator errors
`axint.templates.list`	List all bundled reference templates
`axint.templates.get`	Fetch the source of a named reference template

Built-in prompts: axint.project-start, axint.context-recovery, axint.quick-start, axint.create-intent, and axint.create-widget.

Local stdio install

{
  "mcpServers": {
    "axint": {
      "command": "npx",
      "args": [
        "-y",
        "-p",
        "@axint/compiler",
        "axint-mcp"
      ]
    }
  }
}

The same local config powers Cursor, Claude Code, Codex, VS Code, Windsurf, JetBrains, Neovim, and any other stdio MCP client.

Remote MCP install

{
  "mcpServers": {
    "axint": {
      "url": "https://mcp.axint.ai/mcp"
    }
  }
}

Use the hosted remote endpoint when you want an HTTP MCP connection instead of local Node-based stdio. The canonical endpoint is https://mcp.axint.ai/mcp.

The `.vscode/mcp.json` file

When you run axint init, the scaffolder drops a pre-wired config at .vscode/mcp.json:

{
  "mcpServers": {
    "axint": {
      "command": "npx",
      "args": [
        "-y",
        "-p",
        "@axint/compiler",
        "axint-mcp"
      ]
    }
  }
}

Cursor and Windsurf pick this up automatically. Claude Code reads it if you launch it from the project root or configure it in ~/.config/claude-code/mcp.json.

Why MCP-first matters

The vast majority of App Intent authoring happens inside an AI assistant today. Developers describe what they want in natural language, the assistant drafts the Swift, and then everybody argues with the compiler for an hour.

Axint’s MCP tools short-circuit that loop. Instead of the assistant guessing at the App Intents SDK shape, it calls axint.scaffold with structured params and gets back a guaranteed-compilable file on the first try. If you tweak the file, axint.compile verifies the change in ~10ms.

On a Mac with Swift installed, the assistant can also call axint.compile with sandbox: true to get real swift build output — not just a guess at whether the code is valid, but confirmation that it compiles under the Swift toolchain.