Axint
About
Open-source TypeScript → native Swift compiler for Apple platforms. Compile App Intents, SwiftUI views, WidgetKit widgets, and full apps from TypeScript. AI agents write 5–15× less code. Includes MCP server with tools for compiling, validating, scaffolding, and templating Swift p
Details
- Transport
- SSE
Explore
- Compile TypeScript to Swift for Apple frameworks
- Compile Swift from a JSON schema definition
- Validate TypeScript source before compilation
- Scaffold Xcode-ready Swift projects from compiled output
- Generate starter TypeScript files from built-in templates
- List all available templates with descriptions
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
AxintCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Install globally via npm install -g axint. Add to your MCP config with the command axint-mcp and no arguments. Use the six provided tools (e.g., axint_compile, axint_scaffold) to compile, validate, and generate Swift projects.
axint.status
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 Codex, Claude, or Xcode agent chat to prove which Axint... Use: call first or after an MCP reload to prove the connected server version; do not use as an npm/PyPI lookup. Effects: read-only; writes no files; no auth or network required.
axint.upgrade
Check the latest Axint package and optionally apply the upgrade while preserving the current agent thread. Returns exact install commands, optional Xcode MCP wiring refresh, .axint/upgrade/latest.*... Use: call when axint.status shows a stale server; not for app dependency upgrades. Effects: destructive when apply=true: can run package installs, refresh Xcode wiring, and write .axint/upgrade; may use npm network.
axint.doctor
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... Use: call when MCP wiring, package paths, Xcode setup, or project memory may be stale. Effects: read-only inspection; writes no files; no auth or network required.
axint.xcode.guard
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. Writes... Use: call around long Xcode tasks, context recovery, broad Swift edits, or before claiming runtime proof. Effects: writes .axint/guard proof and may start a session; does not edit app source or use network.
axint.xcode.write
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... Use: use only for guarded Xcode-project file writes; outside Xcode, patch normally and validate after. Effects: writes the requested file inside cwd, may create dirs, validates Swift, and may write guard/check artifacts.
axint.session.start
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... Use: call at the start of a tool-enabled agent session or after context compaction. Effects: writes .axint/session and rehydration artifacts; no auth or network required.
axint.feature
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... Use: use for new Apple-native surfaces; not for repairing existing app bugs. Effects: read-only generated output; writes no files and uses no network.
axint.project.pack
Generate the Axint project-start pack for a new Apple app without writing files. Returns .mcp.json, AGENTS.md, CLAUDE.md, .axint/AXINT_MEMORY.md, .axint/project.json, and .axint/README.md so an Xcode/Codex/Claude agent can install the... Use: use to bootstrap an Apple project with Axint instructions; not to inspect an existing project. Effects: read-only generated file pack; writes no files and uses no network.
axint.project.index
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. Effects: writes .axint/context unless dryRun=true; reads local project files only.
axint.project.syncVersion
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. Effects: updates Axint-owned project instruction files unless dryRun=true; no network.
axint.context.memory
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 when the agent needs compact operating rules. Effects: read-only generated context; writes no files and uses no network.
axint.context.docs
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. Effects: read-only generated docs context; writes no files and uses no network.
axint.suggest
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,... Use: use before generation to choose Apple surfaces; not a substitute for registry search or validation. Effects: local mode is read-only; Pro mode may call Axint endpoint when credentials are configured.
axint.registry.search
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... Use: use before generating code to find reusable packages; not for validating local Swift. Effects: read-only local registry search using AXINT_REGISTRY_PATH or sibling checkout; no network by default.
axint.workflow.check
Read-only agent workflow gate. Requires the current Axint session token from axint.session.start unless requireSession=false is explicitly set. Use this at session start, after context compaction, before planning, writing, building, or... Use: use at stage gates to prove Axint workflow coverage; not a final build/test substitute. Effects: read-only gate but may update tiny workflow freshness stamps; no network.
axint.scaffold
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.... Use: use to create a small TypeScript intent starter; use templates for richer examples. Effects: read-only generated TypeScript; writes no files and uses no network.
axint.compile
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... Use: use when TypeScript DSL source should become Swift; use validate for cheaper preflight only. Effects: read-only generated Swift/diagnostics; writes no files and uses no network.
axint.validate
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,... Use: use for TypeScript DSL diagnostics before Swift output; use swift.validate for existing Swift. Effects: read-only diagnostics; writes no files and uses no network.
axint.fix-packet
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. Effects: read-only local artifact read; writes no files and uses no network.
axint.cloud.check
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... Use: use for Apple-aware source review and repair prompts; provide evidence for UI/runtime claims. Effects: read-only response from provided source/path; may use configured Cloud Check endpoint; no source is sent unless provided.
axint.repair
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... Use: use for existing app bugs with logs, UI symptoms, or runtime evidence; not for greenfield generation. Effects: writes .axint/repair and privacy-safe .axint/feedback artifacts; reads local project files.
axint.feedback.create
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... Use: use when Axint output was weak and you need a privacy-safe issue packet; not for sending source. Effects: writes or reads redacted .axint/feedback packets; never includes source by default.
axint.agent.install
Install the local Axint multi-agent project brain. Writes .axint/agent.json, .axint/context/latest.*, and .axint/coordination files so Codex, Claude, Cursor, Xcode, OpenClaw, 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. Effects: writes .axint/agent, context, and coordination files; no network.
axint.agent.advice
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 Codex, Claude, Cursor, Xcode, or another agent lane. Use: use when multiple tools or agents need the next safest move from local proof. Effects: reads local Axint context/proof and may refresh advice artifacts; no network.
axint.agent.claim
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. Effects: writes local coordination claims under .axint/coordination; no network.
axint.agent.release
Release active local Axint file claims for this agent after finishing or abandoning a task. This keeps Codex, Claude, Cursor, and Xcode from blocking each other on stale claims. Use: use after finishing or abandoning claimed files so other agents are unblocked. Effects: updates local coordination claims under .axint/coordination; no network.
axint.run
Run the enforced Axint Apple build loop outside the Xcode UI. Starts or refreshes the Axint session, validates Swift, runs Cloud Check, executes xcodebuild build/test when a project or workspace... Use: use when the agent must prove Swift validation, Cloud Check, Xcode build/test, and runtime evidence. Effects: starts child processes, writes .axint/run artifacts, may run xcodebuild/tests, and may call Cloud Check.
axint.run.status
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 resume without guessing whether xcodebuild is still active. Effects: read-only local run/job inspection; writes no files and uses no network.
axint.run.cancel
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 Axint run or stuck child process group. Effects: destructive: kills active Axint child process groups; no network.
axint.tokens.ingest
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... Use: use before view/component generation when a design system should be preserved. Effects: read-only Swift token output; writes no files and uses no network.
axint.schema.compile
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... Use: use for token-light JSON-to-Swift generation; use compile for full TypeScript DSL control. Effects: read-only Swift generation; writes no files and uses no network.
axint.swift.validate
Validate existing Swift source against 150 build-time rules (AX700–AX749) including Swift 6 concurrency and Live Activities. Catches bugs Xcode buries behind generic 'type does not conform' errors: missing perform() on AppIntent, missing var... Use: use on generated or edited Swift before build; pair with swift.fix for mechanical repairs. Effects: read-only Swift diagnostics; writes no files and uses no network.
axint.swift.fix
Auto-fix mechanical Swift errors detected by axint.swift.validate. Handles 20+ fix rules: rewrites @State let → @State var, injects perform() into AppIntents, drops var body stubs into Widgets and Apps, adds let date: Date to TimelineEntry,... Use: use after swift.validate when errors are mechanical; inspect remaining diagnostics manually. Effects: read-only fixed-source output; writes no files and uses no network.
axint.templates.list
List all 26 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... Use: use to discover valid template ids before templates.get. Effects: read-only template metadata; writes no files and uses no network.
axint.templates.get
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... Use: use to fetch a complete reference template; edit before compiling into an app. Effects: read-only template source; writes no files and uses no network.
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"axint": {
"axint": {
"command": "axint-mcp",
"args": []
}
}
}
}McpServers
{
"axint": {
"command": "axint-mcp",
"args": []
}
}Agents can write Swift. Axint makes them prove it.
The proof and repair layer for Apple coding agents.
Axint checks the Swift your agent wrote, runs the real Xcode build and tests,
reconciles findings with Apple tooling, and returns signed proof with the exact repairs to make next.
No project rewrite. No source upload.
Prove a project·Try Cloud Preview·Connect an agent·Docs·Examples·Contribute
Local by default. Open source. Ordinary Swift.
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.
npx -y -p @axint/compiler axint prove --dir /path/to/MyApp
Axint 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 aFix Packet: a compact repair artifact with the finding, likely files, exact next action, and rerun command. It also writes asource-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
--fixopts 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.
Generate, Check, Run, Team, and Cloud are different entry points into the same contract: verdict, evidence, findings, next actions, and artifact paths.
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.axintauthoring 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 thecoverage mapfor the implementation and proof boundary of each surface.
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 callaxint.statusandaxint.activateto verify that the server and compiler are connected.
The hosted endpoint athttps://mcp.axint.ai/mcpsupports both established MCP clients and the current stateless protocol generation. Compatibility is continuously checked with official SDK clients; see theprotocol compatibility contract.
For orchestrators that delegate durable work between agents, Axint also ships an authenticatedA2A 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/MyApp
The Agent Card is served at/.well-known/agent-card.json. Loopback use works without setup; non-loopback deployments require bearer authentication by default.
axint.status·axint.activate·axint.upgrade·axint.doctor·axint.session.start·axint.context.memory·axint.context.docs·axint.workflow.check
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
axint.xcode.guard·axint.xcode.write·axint.fix-packet·axint.cloud.check·axint.repair·axint.feedback.create·axint.swift.validate·axint.swift.fix
axint.agent.install·axint.agent.advice·axint.agent.claim·axint.agent.release·axint.run·axint.run.status·axint.run.cancel
axint.quick-start·axint.project-start·axint.context-recovery·axint.create-widget·axint.create-intent
- Live product metricsare regenerated from the codebase.
- The real, CI-gatedbrownfield benchmarkpublishes labeled precision, recall, and abstention cases.
- Coveragemaps supported surfaces to implementation, tests, and proof boundaries.
- Apple platform compatibilitytracks current Xcode, Swift, Siri, App Intents, Foundation Models, SwiftUI, UIKit, and App Store changes against implemented checks and canaries.
- Accessibility-label proofturns common-task accessibility evidence into a reviewable App Store readiness report.
- MCP compatibilitydocuments the hosted server's dual-era transport contract and verification path.
- A2Adocuments durable agent-to-agent proof delegation, authentication, task isolation, and the local execution boundary.
- Architectureexplains the compiler, proof, MCP, A2A, Python, and runtime boundaries.
- Release notesrecord shipped behavior and compatibility changes.
- Securitydocuments reporting, supported releases, telemetry, and dependency policy.
The highest-value contributions improve existing-project precision, Xcode evidence, repair quality, Apple API coverage, and reproducible examples.
- Start with agood first issue.
- Pick up ahelp wantedproblem.
- Read thecontribution guide.
- Ask, propose, or show your work inDiscussions.
The JavaScript package follows the Node.js engine declared inpackage.json. Swift generation runs anywhere Node runs. Xcode build, test, simulator, and runtime proof require macOS with a compatible Xcode toolchain.
Axint isApache-2.0 licensed. Fork it, extend it, and ship with it. The Axint name and visual identity remain protected; seeNOTICEandTRADEMARKS.md.
This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.
An MCP server to help AI assistants to answer questions and generate AccelByte Extend SDK code more effectively .
Instead of direct calling MCP tools, mcpcode server transforms MCP tool calls into TypeScript programs, enabling smarter, lower-latency orchestration by LLMs.
Supercharge your Agent with Semantic Code Intelligence and save 💰 in the process!
AI-to-AI code review platform — Claude, Codex, and Gemini cross-check each other via MCP, REST API, and CLI for consensus-based results.
A code sandbox for AI assistants to safely execute arbitrary code. Requires a 302AI API key for authentication.
Agent-native developer Q&A API with MCP + A2A endpoints for citations, job pickup, and answer submission.
MCP server to dynamically load Claude Code skills into AI agents
MCP bridge that lets Claude Code delegate heavy tasks to the Antigravity CLI (agy) — purpose-built tools, model routing with fallback, session continuity, and output truncation to save Claude's context and tokens.
Exposes local execution of Aider commands as a detached process using MCP.
An MCP server for offloading AI coding tasks to Aider, enhancing development efficiency and flexibility.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
