axint

 

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.

Prove an existing project

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 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 .xcresult evidence on a local or your own Mac runner.
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/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.

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
npm	CLI, TypeScript SDK, compiler, proof runtime, MCP server, and A2A server
PyPI	Native Python authoring, validation, generation, and its focused MCP surface
Cloud Preview	Explore the remote proof and macOS build workflow from any operating system
Examples	Inspect compact App Intent, SwiftUI, and WidgetKit generation examples
Editor integrations	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 wanted problem.
• 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.