axint
Axint is an MCP server that turns TypeScript/JSON contracts and existing Swift into validated, Apple-native code and runs the real Xcode build/test proof loop.
Compile & generate Swift:
axint.compile(TypeScriptdefineIntent()→ Swift App Intent),axint.schema.compile(token-light JSON → intent/view/component/widget/app),axint.scaffold(TypeScript starter),axint.feature(multi-file Apple-native feature packs: intents, views, widgets, plists, entitlements, tests),axint.tokens.ingest(design tokens → SwiftUI token enum).Validate & fix:
axint.validate(134 TypeScript diagnostic rules),axint.swift.validate(Swift build-time rules AX700–AX749, Swift 6 concurrency, Live Activities),axint.swift.fix(mechanical Swift auto-repair),axint.fix-packet(read latest repair artifact),axint.repair(project-aware repair plan for existing apps).Run & prove:
axint.run(orchestrates xcodebuild build/test/runtime,.xcresultevidence, fix loop),axint.run.status,axint.run.cancel,axint.cloud.check(Apple-aware source review with repair prompts).Project context & discovery:
axint.project.pack,axint.project.index(local.axint/contextpack),axint.project.syncVersion,axint.suggest(feature/surface recommendations),axint.registry.search(find reusable published packages),axint.templates.list/axint.templates.get(bundled reference templates),axint.context.memory/axint.context.docs(reloadable agent memory).Agent/orchestration plumbing:
axint.status,axint.activate(smoke test),axint.upgrade,axint.doctor(runtime/wiring audit),axint.session.start,axint.workflow.check(stage gates),axint.agent.install/advice/claim/release(multi-agent coordination and file claims),axint.feedback.create(privacy-safe learning packets).Guarded Xcode editing:
axint.xcode.guard(drift/compaction guards around long tasks) andaxint.xcode.write(in-project file writes with inline Swift validation and Cloud Check).
Compiles TypeScript definitions into native Apple platform code including App Intents for Siri, SwiftUI views, WidgetKit widgets, and full app scaffolds for iOS/macOS development.
Generates production-ready Swift code for iOS applications including App Intents, SwiftUI views, WidgetKit widgets, and complete app scaffolds from TypeScript definitions.
Compiles TypeScript definitions into native macOS application components including App Intents, SwiftUI views, settings scenes, and full app scaffolds.
Provides the runtime environment for the Axint compiler and MCP server, enabling compilation of Apple platform code from TypeScript/JSON definitions.
Hosts the Axint compiler package (@axintai/compiler) for installation and distribution of the Apple platform code generation tools.
Supports Python as an input language alongside TypeScript and JSON, feeding into the same intermediate representation for Apple platform code generation.
Generates idiomatic, production-ready Swift code with native type fidelity (int → Int, double → Double, date → Date, etc.) from TypeScript/JSON/Python definitions.
Compiles TypeScript definitions using the TypeScript compiler API (same as tsc) with full type fidelity into native Apple platform Swift code.
Generates Xcode-compatible Swift code, plist files, and entitlements for Apple platform development that can be directly integrated into Xcode projects.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
A plausible patch is not proof.
Apple software is a graph of contracts. SwiftUI state, App Intents, Siri and Shortcuts metadata, widgets, entitlements, privacy declarations, concurrency, build settings, tests, and runtime behavior all have to agree. Code that looks right can still fail to compile, miss an interaction, or violate a platform contract.
Axint puts static analysis and Apple tooling into one repair loop. Static checks identify leads; Xcode build and test output can confirm, contextualize, or suppress them. The result stays compact enough for the next agent turn while full logs and artifacts remain on disk.
Evidence class | What it means |
Confirmed | Deterministic analysis or matching compiler, build, or test evidence supports the finding. |
Probable | Strong static evidence identifies a likely problem, but decisive Apple-tooling evidence is incomplete. |
Advisory | A heuristic identifies a quality, accessibility, privacy, interaction, design, or runtime concern for review. |
Suppressed | Stronger evidence or a project-local review contradicts the finding; it remains in the receipt without blocking the result. |
Related MCP server: xcode-mcp
Prove an existing project
npx -y -p @axint/compiler axint prove --dir /path/to/MyAppAxint discovers the Xcode project and scheme, checks existing Swift, runs the
available build and tests, reconciles the findings, and writes proof under
.axint/proof.
The default local run requires no account or configuration. It does not change Swift, upload source, install project instructions, install memory or MCP configuration, apply fixes, or rewrite the project.
When a failure needs another turn, Axint returns a Fix Packet: a compact repair artifact with the finding, likely files, exact next action, and rerun command. It also writes a source-free receipt: a signed proof file containing evidence, results, hashes, and repair information without project source.
axint prove --dir /path/to/MyApp --fix
axint receipt verify /path/to/MyApp/.axint/proof/latest.proof.json--fix opts into supported deterministic rewrites and reruns the proof loop.
Receipt verification checks payload integrity and the embedded Ed25519 signer.
A locally signed receipt does not establish an externally trusted identity
unless CI or the receiving team pins the signer fingerprint or a managed
signing key.
Use it in a pull request
Run axint prove on a macOS runner with Xcode. For a starter workflow and
the signed-receipt output, see GitHub Actions setup.
A pass needs real Apple-tooling evidence; missing tests or an unavailable build
are not silently reported as proof.
One proof contract
Generate, Check, Run, Team, and Cloud are different entry points into the same contract: verdict, evidence, findings, next actions, and artifact paths.
Mode | Role in the proof loop |
Check | Validate generated or existing Swift with evidence-aware diagnostics and appropriate abstention. |
Run | Orchestrate resumable build, test, runtime, and |
Generate | Compile smaller contracts into inspectable App Intents, SwiftUI views, widgets, Live Activities, app shells, metadata, and tests. |
Team | Preserve project context, sessions, file claims, repair packets, and handoffs across agents. |
Cloud | Run hosted checks and preserve shared proof history when local Apple tooling is unavailable. |
Generate when it helps
Generation is optional for existing projects. When a feature is easier to describe as a smaller contract, Axint can emit ordinary Swift and the companion metadata required by the selected Apple surface.
import { defineIntent, param } from "@axint/compiler";
export default defineIntent({
name: "CreateCalendarEvent",
title: "Create Calendar Event",
description: "Creates a calendar event for the user.",
domain: "productivity",
params: {
title: param.string("Event title"),
date: param.date("Event date"),
duration: param.duration("Event duration"),
location: param.string("Location", { required: false }),
},
perform: async ({ title, date }) => ({
success: true,
message: `Created ${title} on ${date}`,
}),
});axint compile create-calendar-event.ts --out ios/Intents/TypeScript, Python, JSON IR, and the experimental .axint authoring surface
lower into inspectable Apple-native output. The TypeScript pipeline also
supports views, widgets, apps, Live Activities, App Enums, UnionValue schemas,
App Shortcuts, and extension scaffolds; see the coverage map
for the implementation and proof boundary of each surface.
Connect your agent
Axint ships an MCP server for standards-compatible hosts:
{
"mcpServers": {
"axint": {
"command": "npx",
"args": ["-y", "-p", "@axint/compiler", "axint-mcp"]
}
}
}Start a fresh tool session, then call axint.status and axint.activate to
verify that the server and compiler are connected.
The hosted endpoint at https://mcp.axint.ai/mcp supports both established MCP
clients and the current stateless protocol generation. Compatibility is
continuously checked with official SDK clients; see the
protocol compatibility contract.
For orchestrators that delegate durable work between agents, Axint also ships an authenticated A2A server. MCP exposes individual tools; A2A exposes complete check, diagnosis, proof, and repair-planning tasks with status, streaming updates, cancellation, and source-free result artifacts.
npx -y -p @axint/compiler axint-a2a --project-root /path/to/MyAppThe Agent Card is served at /.well-known/agent-card.json. Loopback use works
without setup; non-loopback deployments require bearer authentication by
default.
Start, recover, and inspect
axint.status · axint.activate · axint.upgrade · axint.doctor ·
axint.session.start · axint.context.memory · axint.context.docs ·
axint.workflow.check
Generate and discover
axint.feature · axint.project.pack · axint.project.index ·
axint.project.syncVersion · axint.suggest · axint.registry.search ·
axint.scaffold · axint.compile · axint.validate · axint.tokens.ingest ·
axint.schema.compile · axint.templates.list · axint.templates.get
Check and repair
axint.xcode.guard · axint.xcode.write · axint.fix-packet ·
axint.cloud.check · axint.repair · axint.feedback.create ·
axint.swift.validate · axint.swift.fix
Coordinate and run
axint.agent.install · axint.agent.advice · axint.agent.claim ·
axint.agent.release · axint.run · axint.run.status · axint.run.cancel
Built-in prompts
axint.quick-start · axint.project-start · axint.context-recovery ·
axint.create-widget · axint.create-intent
Public proof
Live product metrics are regenerated from the codebase.
The real, CI-gated brownfield benchmark publishes labeled precision, recall, and abstention cases.
Coverage maps supported surfaces to implementation, tests, and proof boundaries.
Apple platform compatibility tracks current Xcode, Swift, Siri, App Intents, Foundation Models, SwiftUI, UIKit, and App Store changes against implemented checks and canaries.
Accessibility-label proof turns common-task accessibility evidence into a reviewable App Store readiness report.
MCP compatibility documents the hosted server's dual-era transport contract and verification path.
A2A documents durable agent-to-agent proof delegation, authentication, task isolation, and the local execution boundary.
Architecture explains the compiler, proof, MCP, A2A, Python, and runtime boundaries.
Release notes record shipped behavior and compatibility changes.
Security documents reporting, supported releases, telemetry, and dependency policy.
Ecosystem
Surface | Use it for |
CLI, TypeScript SDK, compiler, proof runtime, MCP server, and A2A server | |
Native Python authoring, validation, generation, and its focused MCP surface | |
Explore the remote proof and macOS build workflow from any operating system | |
Inspect compact App Intent, SwiftUI, and WidgetKit generation examples | |
Connect Xcode, VS Code, Cursor, JetBrains, Neovim, and other hosts |
Contribute
The highest-value contributions improve existing-project precision, Xcode evidence, repair quality, Apple API coverage, and reproducible examples.
Start with a
good first issue.Pick up a
help wantedproblem.Read the contribution guide.
Ask, propose, or show your work in Discussions.
Requirements and license
The JavaScript package follows the Node.js engine declared in
package.json. Swift generation runs anywhere Node runs. Xcode
build, test, simulator, and runtime proof require macOS with a compatible Xcode
toolchain.
Axint is Apache-2.0 licensed. Fork it, extend it, and ship with it. The Axint name and visual identity remain protected; see NOTICE and TRADEMARKS.md.
Available Tools
36 toolsaxint.activateARead-onlyIdempotentInspect
Run a source-free compiler smoke test through the real Axint pipeline. Use immediately after installing or connecting Axint so the current agent proves it did more than start the MCP server. Use: call immediately after install or first MCP connection; use validate or run for project checks. Inputs: format changes rendering only; the smoke test has no project inputs. Effects: read-only built-in compiler smoke test; writes no files and uses no network.
Inputs: format. Returns: text, isError
axint.agent.adviceAInspect
Ask the local Axint project brain what this agent should do next. Reads project context, latest run proof, latest repair plan, and active file claims, then returns host-specific guidance for Xcode, patch-first editors, or another agent lane. Use: use when local proof should choose the next move; use suggest for greenfield ideas and repair for known bugs. Inputs: cwd selects local context; question and modifiedFiles focus the next-move recommendation. Effects: reads local Axint context/proof and may refresh advice artifacts; no network.
Inputs: cwd, agent, issue, format, +1 more. Returns: text, isError
axint.agent.claimAInspect
Claim files before an agent edits them so other agents do not patch the same SwiftUI/App files concurrently. Claims are local, short-lived, and stored in .axint/coordination/claims.json. Use: use before editing shared files in parallel-agent work; release claims when done. Inputs: agentId and files identify the claim; ttlMinutes bounds ownership and force overrides stale claims. Effects: writes local coordination claims under .axint/coordination; no network.
Inputs: files (required), cwd, task, agent, +2 more. Returns: text, isError
axint.agent.installAIdempotentInspect
Install the local Axint multi-agent project brain. Writes .axint/agent.json, .axint/context/latest.*, and .axint/coordination files so AI agents, Xcode, and humans coordinate through the same local truth layer. Use: use once per project to create local multi-agent coordination; not needed for one-off compile. Inputs: cwd scopes local coordination; projectName and hosts shape generated project-brain files. Effects: writes .axint/agent, context, and coordination files; no network.
Inputs: cwd, agent, force, format, +3 more. Returns: text, isError
axint.agent.releaseAIdempotentInspect
Release active local Axint file claims for this agent after finishing or abandoning a task. This keeps parallel agents and Xcode from blocking each other on stale claims. Use: use after finishing or abandoning claimed files; use agent.claim before edits and agent.advice for next steps. Inputs: agentId releases only its matching claims unless files narrow the release set. Effects: updates local coordination claims under .axint/coordination; no network.
Inputs: all, cwd, agent, files, +1 more. Returns: text, isError
axint.cloud.checkARead-onlyIdempotentInspect
Run an agent-callable Cloud Check against Swift or Axint TypeScript source. Accepts inline source or a sourcePath, then returns a Cloud-style verdict, Apple-specific findings, next steps, an AI repair prompt, and a redacted compiler feedback signal when the check finds a bug. Use: use for Apple-aware source review and repair prompts; provide evidence for UI/runtime claims. Inputs: provide source or sourcePath, not both; evidence fields strengthen UI and runtime claims. Effects: read-only response from provided source/path; may use configured Cloud Check endpoint; no source is sent unless.
Inputs: format, source, fileName, language, +11 more. Returns: text, isError
axint.compileARead-onlyIdempotentInspect
Compile TypeScript source (defineIntent() call) into native Swift App Intent code. Returns { swift, infoPlist?, entitlements? } as a string — no files written, no network requests. On validation failure, returns diagnostics (severity, AX error code, position, fix suggestion) instead of Swift. Use: use when TypeScript DSL source should become Swift; use validate for cheaper preflight only. Inputs: source is TypeScript DSL text; options add sandbox, format, plist, or entitlement proof without writing files. Effects: read-only generated Swift/diagnostics; writes no files and uses no network.
Inputs: source (required), format, fileName, emitInfoPlist, +1 more. Returns: text, isError
axint.context.docsARead-onlyIdempotentInspect
Return the project-local Axint docs context that agents should reload after new chats or context compaction. This is the durable docs memory that keeps the agent using Axint instead of forgetting the workflow. Use: use after compaction when the agent needs workflow docs without rereading the whole site. Inputs: cwd selects project docs context; include sections only when the longer runbook is needed. Effects: read-only generated docs context; writes no files and uses no network.
Inputs: platform, projectName, expectedVersion. Returns: text, isError
axint.context.memoryARead-onlyIdempotentInspect
Return the compact Axint operating memory that agents should reload at new chat start, after context compaction, or after long coding drift. Use this to keep Axint top-of-mind without rereading the full docs. Use: use after compaction or session restart for compact operating rules; use context.docs for longer workflow docs. Inputs: cwd selects project memory; format changes rendering without changing content. Effects: read-only generated context; writes no files and uses no network.
Inputs: platform, projectName, expectedVersion. Returns: text, isError
axint.doctorARead-onlyIdempotentInspect
Audit the current Axint runtime and project wiring: running MCP version, expected version, Node/npm/npx paths, project .mcp.json, AGENTS.md, CLAUDE.md, .axint/project.json, and Xcode Claude Agent registration. Use this when an agent might be connected to a stale Axint process or when a new project needs first-try MCP setup proof. Use: call when MCP wiring, package paths, Xcode setup, or project memory may be stale; use run for build proof. Inputs: cwd selects the project; expectedVersion turns a runtime mismatch into a blocker. Effects: read-only inspection; writes no files; no auth or network required.
Inputs: cwd, format, expectedVersion. Returns: text, isError
axint.featureARead-onlyIdempotentInspect
Generate a scaffolded Apple-native feature package from a description. Returns multiple files: compile-aware Swift source, companion widget/view, Info.plist fragments, entitlements, and XCTest scaffolds — all structured file-by-file so an Xcode agent can write each file directly into the project. Use: use for new Apple-native surfaces; not for repairing existing app bugs. Inputs: description is the feature brief; kind and platform constrain the generated package. Effects: read-only generated output; writes no files and uses no network.
Inputs: description (required), name, domain, format, +7 more. Returns: text, isError
axint.feedback.createAInspect
Create or read a privacy-safe learning packet for Axint repair intelligence. Packets include project shape, diagnostic codes, issue class, redacted evidence, and likely product owner, but never include source code. Users can inspect the JSON before sending it to Axint Cloud. Use: create a privacy-safe issue packet when output was weak, or read the latest packet; never use it to send source. Inputs: latest reads instead of creates; outcome and diagnostic fields stay source-free unless excerpts are explicit. Effects: writes or reads redacted .axint/feedback packets; never includes source by default.
Inputs: cwd, agent, issue, format, +12 more. Returns: text, isError
axint.fix-packetARead-onlyIdempotentInspect
Read the latest Fix Packet that Axint emitted locally after a compile or watch run. Returns the exact repair artifact that AI tools or Xcode helpers should consume next: verdict, top findings, full diagnostics, next steps, and an AI-ready fix prompt. Use: use after a local compile/watch/check emitted a packet; not a new analysis pass. Inputs: cwd and path locate an existing packet; latest selects the newest artifact and never reruns analysis. Effects: read-only local artifact read; writes no files and uses no network.
Inputs: cwd, format, packetDir. Returns: text, isError
axint.project.indexAIdempotentInspect
Scan the local Apple project and write a compact .axint/context pack so Axint can reason over changed files, nearby SwiftUI surfaces, and interaction-risk files instead of only one source file at a time. Use: use before project-aware repair, multi-file SwiftUI work, or interaction-risk analysis. Inputs: changedFiles seed related-file discovery; dryRun returns the pack without writing .axint/context. Effects: writes .axint/context unless dryRun=true; reads local project files only.
Inputs: dryRun, format, targetDir, includeGit, +2 more. Returns: text, isError
axint.project.packARead-onlyIdempotentInspect
Generate the Axint project-start pack for a new Apple app without writing files. Use: use to bootstrap a new Apple project with Axint instructions; use project.index to inspect an existing project. Inputs: cwd and projectName identify the project; host choices control generated integration files. Effects: read-only generated file pack; writes no files and uses no network.
Inputs: mode, agent, format, targetDir, +1 more. Returns: text, isError
axint.project.syncVersionAIdempotentInspect
Update Axint-owned project-pack version hints after an upgrade. Use this after axint.upgrade or npm/pip upgrades so .axint/project.json, AGENTS.md, CLAUDE.md, and Axint rehydration docs stop pointing agents at an older package version. Use: use after package upgrades so local project-pack hints stop naming old Axint versions. Inputs: cwd scopes Axint-owned files; targetVersion overrides running version; dryRun prevents writes. Effects: updates Axint-owned project instruction files unless dryRun=true; no network.
Inputs: dryRun, format, version, targetDir. Returns: text, isError
axint.registry.searchARead-onlyIdempotentInspect
Search the Axint Registry for already-published packages that match a natural-language query. Use this BEFORE calling axint.feature or axint.compile so the agent can install an existing package instead of regenerating Swift the community has already shipped. Use: use before generating code to find reusable packages; not for validating local Swift. Inputs: query drives ranking; kind and platform narrow results without changing the registry source. Effects: read-only local registry search using AXINT_REGISTRY_PATH or sibling checkout; no network by default.
Inputs: query (required), kind, limit, minScore, +1 more. Returns: text, isError
axint.repairAInspect
Plan a project-aware Apple repair for existing apps. Indexes the local project, classifies build/UI/runtime evidence, runs Cloud Check when source is provided, ranks likely SwiftUI/App files, returns a host-aware patch/proof plan, and writes .axint/repair plus a privacy-safe .axint/feedback packet. Use: use for existing app bugs with logs, UI symptoms, or runtime evidence; not for greenfield generation. Inputs: describe the observed bug and attach logs or evidence; modifiedFiles and project index narrow the plan. Effects: writes .axint/repair and privacy-safe .axint/feedback artifacts; reads local project files.
Inputs: issue (required), cwd, agent, format, +13 more. Returns: text, isError
axint.runAInspect
Run the enforced Axint Apple build loop outside the Xcode UI. Use: use for the complete proof loop; use swift.validate, cloud.check, or fix-packet when only one stage is needed. Inputs: integration=minimal enforces local advisory no-fix behavior; background returns a job id; outputDir controls artifacts. Effects: starts child processes, writes .axint/run artifacts, may run xcodebuild/tests, and may call Cloud Check.
Inputs: cwd, fix, agent, dryRun, +28 more. Returns: text, isError
axint.run.cancelADestructiveInspect
Cancel the latest or selected Axint run by killing active child process groups. Use this when xcodebuild or a UI-test runner survived an MCP timeout or transport close. Use: use only to stop an active run or stuck child process group; use run.status for read-only inspection. Inputs: jobId is required; signal and grace period control escalation before killing the process group. Effects: destructive: kills active Axint child process groups; no network.
Inputs: id, cwd, format. Returns: text, isError
axint.run.statusARead-onlyIdempotentInspect
Read the latest or selected Axint run job record, including active child process IDs. Use this when a long xcodebuild run may still be active after an MCP timeout or client disconnect. Use: use after MCP timeouts or long builds to inspect or rejoin; it does not start, rerun, or cancel work. Inputs: jobId selects a background run; includeLogs changes returned detail without changing the job. Effects: read-only local run/job inspection; writes no files and uses no network.
Inputs: id, cwd, format. Returns: text, isError
axint.scaffoldARead-onlyIdempotentInspect
Generate a starter TypeScript intent file from a name and description. Returns a complete defineIntent() source string ready to save as a .ts file — no files are written, no network requests made. On invalid domain values, returns an error string. The output compiles directly with axint.compile. Use: use to create a small TypeScript intent starter; use templates.get for richer examples and compile for Swift output. Inputs: name must be PascalCase; params define the starter contract; domain defaults to general. Effects: read-only generated TypeScript; writes no files and uses no network.
Inputs: name (required), description (required), domain, params. Returns: text, isError
axint.schema.compileARead-onlyIdempotentInspect
Compile a minimal JSON schema directly to Swift, bypassing the TypeScript DSL entirely. Supports intents, views, components, widgets, and full apps via the 'type' parameter. Uses ~20 input tokens vs hundreds for TypeScript — ideal for LLM agents optimizing token budgets. Use: use for token-light JSON-to-Swift generation; use compile for full TypeScript DSL control and scaffold for TS starters. Inputs: schema kind selects intent, view, widget, or app output; options add companion metadata. Effects: read-only Swift generation; writes no files and uses no network.
Inputs: name (required), type (required), body, entry, +14 more. Returns: text, isError
axint.session.startAInspect
Start an enforced Axint agent session. Writes .axint/session/current.json plus token-scoped session history, refreshes .axint/AXINT_REHYDRATE.md, returns compact operating memory, docs context, a session token, and the exact axint.workflow.check args. Use: call at the start of a tool-enabled agent session or after context compaction. Inputs: cwd scopes session files; prior token and context inputs preserve continuity after compaction. Effects: writes .axint/session and rehydration artifacts; no auth or network required.
Inputs: agent, format, platform, targetDir, +3 more. Returns: text, isError
axint.statusARead-onlyIdempotentInspect
Report the exact running Axint MCP server version, package path, uptime, registered tool count, and same-thread MCP reload/update instructions. Use this as the first tool in a new AI-agent or Xcode chat to prove which Axint process the agent is actually connected to. This answers the running MCP server, not a guessed npm, PyPI, or docs version. Use: call first or after an MCP reload to prove the connected server version; do not use as an npm/PyPI lookup. Inputs: format changes rendering only; no project path is required. Effects: read-only; writes no files; no auth or network required.
Inputs: format. Returns: text, isError
axint.suggestARead-onlyIdempotentInspect
Suggest Apple-native features for an app based on its description. The domain is only a weak hint; the app description wins. Returns a ranked list of features with recommended surfaces (intent, widget, view, component, store, app), estimated complexity, and a one-line description for each. Use: use before generation to choose Apple surfaces; not a substitute for registry search or validation. Inputs: prompt is the product brief; dir adds project context; Pro mode is used only when configured. Effects: local mode is read-only; Pro mode may call Axint endpoint when credentials are configured.
Inputs: appDescription (required), mode, goals, limit, +6 more. Returns: text, isError
axint.swift.fixARead-onlyIdempotentInspect
Auto-fix mechanical Swift errors detected by axint.swift.validate. Use: use after swift.validate when errors are mechanical; inspect remaining diagnostics manually. Inputs: source is required; codes limits mechanical rewrites; maxPasses bounds convergence attempts. Effects: read-only fixed-source output; writes no files and uses no network.
Inputs: source (required), file, format. Returns: text, isError
axint.swift.validateARead-onlyIdempotentInspect
Validate existing Swift source against Axint's Apple-specific build-time rules (AX700–AX749) including Swift 6 concurrency and Live Activities. Use: use on generated or edited Swift before build; pair with swift.fix for mechanical repairs. Inputs: source or sources provide Swift text; projectIndex enables cross-file checks; platform filters rules. Effects: read-only Swift diagnostics; writes no files and uses no network.
Inputs: source (required), file. Returns: text, isError
axint.templates.getARead-onlyIdempotentInspect
Retrieve the full TypeScript source code of a specific bundled template by id. Returns a complete, compilable defineIntent() file as a string — ready to save as .ts and compile with axint.compile. Includes perform() logic, parameter definitions, and domain-specific patterns. Use: use after templates.list to fetch a complete reference template; edit it before calling compile. Inputs: id must come from templates.list; format changes source versus metadata rendering. Effects: read-only template source; writes no files and uses no network.
Inputs: id (required). Returns: text, isError
axint.templates.listARead-onlyIdempotentInspect
List all bundled reference templates in the Axint SDK. Returns a JSON array of { id, name, description } objects — one per template. Templates cover messaging, productivity, health, finance, commerce, media, navigation, smart-home, and entity/query patterns. No input parameters required, no files written, no network requests, no side effects. Use: use to discover valid template ids before templates.get. Inputs: category and query filter metadata; call without filters to discover every valid id. Effects: read-only template metadata; writes no files and uses no network.
Returns: text, isError
axint.tokens.ingestARead-onlyIdempotentInspect
Ingest design tokens from JSON, JS/TS object exports, or CSS variables and return a SwiftUI token enum. Use this before generating Swarm-style views/components so agents can preserve exact brand colors, dimensions, radii, spacing, and typography. No files are written. Use: use before view/component generation when a design system should be preserved. Inputs: tokens accepts structured design values; enumName and accessLevel shape generated Swift names. Effects: read-only Swift token output; writes no files and uses no network.
Inputs: format, source, namespace, sourcePath. Returns: text, isError
axint.upgradeADestructiveInspect
Check the latest Axint package and optionally apply the upgrade while preserving the current agent thread. Use: call when axint.status shows a stale server; not for app dependency upgrades. Inputs: apply defaults false; targetVersion selects the install, while reinstallXcode and writeReport matter only when applying. Effects: destructive when apply=true: can run package installs, refresh Xcode wiring, and write .axint/upgrade; may use npm.
Inputs: cwd, apply, format, writeReport, +3 more. Returns: text, isError
axint.validateARead-onlyIdempotentInspect
Validate a TypeScript intent definition without generating Swift. Runs the full Axint validation pipeline (134 diagnostic rules) and returns a JSON array of diagnostics: { severity: 'error'|'warning', code: 'AXnnn', line: number, column: number, message: string, suggestion?: string }. Returns an empty array [] when validation passes. Use: use for TypeScript DSL diagnostics before Swift output; use swift.validate for existing Swift. Inputs: source is TypeScript DSL text; strictness options affect diagnostics only and never emit Swift. Effects: read-only diagnostics; writes no files and uses no network.
Inputs: source (required). Returns: text, isError
axint.workflow.checkAInspect
Agent workflow gate that records a local freshness stamp. Requires the current Axint session token from axint.session.start unless requireSession=false is explicitly set. Use: use at stage gates to prove workflow coverage; use status for version checks and run for build/test proof. Inputs: stage selects the gate; sessionToken proves continuity; allowNoSession is an explicit escape hatch. Effects: writes a local .axint/session workflow freshness stamp; edits no app source and uses no network.
Inputs: cwd, agent, notes, stage, +19 more. Returns: text, isError
axint.xcode.guardAInspect
Guard an Xcode agent session against context compaction and Axint drift. Checks project memory files, active Axint session, latest Axint Run or guard proof, and long-task freshness. Use: call around long Xcode tasks, context recovery, broad Swift edits, or before claiming runtime proof; use workflow.check. Inputs: stage selects the gate; modifiedFiles and notes narrow drift checks; autoStartSession defaults true. Effects: writes .axint/guard proof and may start a session; does not edit app source or use network.
Inputs: cwd, notes, stage, format, +10 more. Returns: text, isError
axint.xcode.writeAInspect
Write a file inside the Xcode project through the Axint guard path. For Swift files, runs axint.swift.validate and axint.cloud.check immediately, then records .axint/guard/latest.* proof. Use this instead of raw XcodeWrite when an agent is editing Apple-native files during a long task. Use: use only for guarded Xcode-project file writes; outside Xcode, patch normally and validate after. Inputs: path must remain inside cwd; createDirs, validateSwift, and cloudCheck default true. Effects: writes the requested file inside cwd, may create dirs, validates Swift, and may write guard/check artifacts.
Inputs: path (required), content (required), cwd, notes, +8 more. Returns: text, isError
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 36 tools
Most tools have distinct purposes and clear descriptions, but some overlap exists between validation tools (axint.validate vs axint.swift.validate vs axint.cloud.check) and run-related tools (axint.run vs axint.run.status), which could cause minor confusion.
All tool names follow a consistent dot-separated pattern with lowercase and underscore style, clearly indicating domain and action (e.g., axint.compile, axint.workflow.check). No mixing of conventions.
36 tools is on the high side for an MCP server, covering many sub-domains. While each tool serves a specific purpose, the sheer number could overwhelm agents and users, making it borderline for appropriate scope.
The tool set covers the full lifecycle of Apple-native development with Axint: setup, compilation, validation, repair, templates, design tokens, and session management. Minor gaps like deployment are outside the stated purpose.
Maintenance
Related MCP Connectors
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Search a curated catalog of agent skills, MCP servers and rules for Swift, SwiftUI, Xcode and iOS.
Build, validate, deploy — HTTP APIs, cron jobs, webhooks and MCP tools — from your AI client.
One message in, a full agentic application out: website and MCP app, live. Built from any AI client.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server providing curated Swift and SwiftUI best practices from leading iOS developers, including patterns and real-world code examples from Swift by Sundell, SwiftLee, and other trusted sources.426 npm13MIT
- FlicenseAqualityCmaintenanceEnables control of the iOS Simulator using the xcrun simctl command-line utility. It allows users to manage devices, install and launch apps, send push notifications, and simulate device features like GPS location.12-
- AlicenseNot gradedqualityCmaintenanceAI-native SwiftUI component library with full-stack recipes — connect via MCP for instant access.3,273MIT

blitz-mcpofficial
AlicenseNot gradedqualityDmaintenanceBlitz-mcp gives AI agents full control over iOS/macOS development — boot simulators, interacts with physical iPhones, browse databases, trigger builds, and submit apps to App Store Connect via 30+ MCP tools.1,771Apache 2.0