Axint
Proof and repair for Apple coding agents: validate Swift, run Xcode evidence, and repair failures.
| Endpoint | https://mcp.axint.ai/mcp (streamable-http) |
|---|---|
| Registry version | 0.6.0 |
| Now | 36 tools · grade F (29) · pin ts_f6efed8f5e10518fa939ed5740246aeb · protocol 2025-06-18 |
| First / last listed | 2026-10-30 01:12 UTC / 2026-10-30 01:12 UTC |
| Grade over time | 2026-10-30: F (29), 36 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: axint.compile axint.validate axint.swift.validate axint.swift.fix axint.scaffold axint.templates.list axint.templates.get axint.repair axint.status axint.activate axint.upgrade axint.doctor axint.xcode.guard axint.xcode.write axint.session.start axint.feature axint.project.pack axint.project.index axint.project.syncVersion axint.context.memory axint.context.docs axint.suggest axint.registry.search axint.workflow.check axint.fix-packet axint.cloud.check axint.feedback.create axint.agent.install axint.agent.advice axint.agent.claim axint.agent.release axint.run axint.run.status axint.run.cancel axint.tokens.ingest axint.schema.compile
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 (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: params: source*, fileName, emitInfoPlist, emitEntitlements, format |
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, message: string, suggestion?: string }. Returns an empty array [] when validation passes. Use: use for TypeScript DSL diagnostics before Swift output; use params: source* |
axint.swift.validate | 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 fi params: source*, file |
axint.swift.fix | 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. params: source*, file, format |
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. The output compiles directly with axint.compile. Use: use to create a small TypeScript intent starter; use templates.get for richer examples and compile params: name*, description*, domain, params |
axint.templates.list | 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 template params: none |
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 domain-specific patterns. Use: use after templates.list to fetch a complete reference template; edit it before calling compile. Inputs: id must come f params: id* |
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 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 gener params: cwd, issue*, source, sourcePath, fileName, platform, agent, expectedBehavior, actualBehavior, xcodeBuildLog, testFailure, runtimeFailure, changedFiles, projectContextPath, writeReport, writeFeedback, format |
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 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 c params: format |
axint.activate | 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 com params: format |
axint.upgrade | 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 wir params: cwd, targetVersion, latestVersion, apply, reinstallXcode, writeReport, format |
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 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 me params: cwd, expectedVersion, format |
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. 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; autoStartSessio params: cwd, projectName, expectedVersion, platform, stage, sessionToken, modifiedFiles, notes, lastAxintTool, lastAxintResult, maxMinutesSinceAxint, autoStartSession, writeReport, format |
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 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: pa params: cwd, path*, content*, projectName, expectedVersion, platform, sessionToken, createDirs, validateSwift, cloudCheck, notes, format |
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 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 params: targetDir, projectName, expectedVersion, platform, agent, ttlMinutes, format |
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 file directly into the project. Use: use for new Apple-native surfaces; not for repairing existing app bugs. Inputs: description is th params: description*, surfaces, name, appName, domain, params, platform, tokenNamespace, componentKind, context, format |
axint.project.pack | 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. params: projectName, targetDir, agent, mode, format |
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. Inputs: changedFiles seed related-file discovery; dryRun returns the pack without writing .axint/contex params: targetDir, projectName, changedFiles, includeGit, dryRun, format |
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. Inputs: cwd scopes Axint-owned files; targetVersion overrides running ve params: targetDir, version, dryRun, format |
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 for compact operating rules; use context.docs for longer workflow docs. Inputs: cwd selects project memory; format changes rendering without chang params: projectName, expectedVersion, platform |
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. Inputs: cwd selects project docs context; include sections only when the longer runbook is need params: projectName, expectedVersion, platform |
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, 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. Inpu params: appDescription*, domain, mode, platform, audience, exclude, goals, stage, constraints, limit |
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 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 na params: query*, kind, platform, limit, minScore |
axint.workflow.check | 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: params: cwd, sessionStarted, agent, sessionToken, requireSession, stage, surfaces, modifiedFiles, ranSuggest, ranStatus, readRehydrationContext, readAgentInstructions, readDocsContext, ranFeature, ranRepair, featureBypassReason, ranSwiftValidate, ranCloudCheck, xcodeBuildPassed, xcodeTestsPassed, notes, availableTools, format |
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. Inputs: cwd and path locate an existing packet; latest selects params: cwd, packetDir, format |
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 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 o params: source, sourcePath, fileName, language, platform, expectedVersion, localPackageVersion, cloudRulesetVersion, xcodeBuildLog, testFailure, runtimeFailure, expectedBehavior, actualBehavior, projectContextPath, format |
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 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 params: cwd, latest, issue, source, sourcePath, fileName, platform, agent, expectedBehavior, actualBehavior, xcodeBuildLog, testFailure, runtimeFailure, changedFiles, projectContextPath, format |
axint.agent.install | 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-brai params: cwd, projectName, agent, privacyMode, providerMode, force, format |
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 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 params: cwd, issue, agent, changedFiles, format |
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. Inputs: agentId and files identify the claim; ttlMinutes bounds ownership and force overrides stale claims. Effects: writes lo params: cwd, agent, task, files*, ttlMinutes, format |
axint.agent.release | 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 coo params: cwd, agent, files, all, format |
axint.run | 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 ma params: cwd, projectName, expectedVersion, platform, agent, scheme, workspace, project, destination, configuration, derivedDataPath, testPlan, onlyTesting, modifiedFiles, skipBuild, skipTests, runtime, runtimeTimeoutSeconds, timeoutSeconds, expectedBehavior, actualBehavior, runtimeFailure, integration, localOnly, advisory, fix, outputDir, dryRun, writeReport, background, includeSource, format |
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 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. Effect params: cwd, id, format |
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 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 params: cwd, id, format |
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 are written. Use: use before view/component generation when a design system should be preserved. Inputs: tokens accepts structured design values params: source, sourcePath, namespace, format |
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 optimizing token budgets. Use: use for token-light JSON-to-Swift generation; use compile for full TypeScript DSL control and scaffold for TS starters. Inp params: type*, name*, title, description, componentKind, tokenNamespace, domain, params, props, state, body, displayName, families, entry, refreshInterval, platform, scenes, format |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.