Agents need a compiler for Apple-native software.
Coding agents can write Swift. They cannot reliably remember every App Intents schema, plist key, entitlement, privacy string, widget constraint, and Spotlight rule across repeated edits. Axint turns the feature into a smaller contract, emits ordinary Swift, validates the Apple-specific pieces, and gives the next agent run an exact repair packet.
Define
TypeScript, Python, or preview .axint captures the feature shape.
Lower
Axint normalizes the request into an Apple-native IR contract.
Emit
The compiler writes Swift, plist fragments, entitlements, and app metadata.
Check
Cloud or local validation returns pass, needs_review, or fail.
Repair
Fix Packet gives the next agent run the exact correction path.
Plausible Swift is not the same thing as an Apple-native contract.
An agent generates an App Intent. The code looks close. Then Xcode, Spotlight, Shortcuts, a widget surface, or review exposes the missing part: a privacy usage string, entitlement mismatch, bad parameter summary, framework import, concurrency issue, or widget shape problem. The next prompt gets a wall of logs instead of a scoped correction.
Guess
An agent writes plausible Swift, metadata, plist copy, and entitlements from a broad prompt.
Fail
Xcode, Shortcuts, Spotlight, widgets, or review exposes the missing Apple-specific contract.
Repair
Axint returns a named finding, the reason it matters, and the next edit the agent should make.
Ask for the feature. Keep the contract small. Let the compiler own the ceremony.
A HealthKit workout intent needs Swift, entitlements, plist copy, metadata, and validation logic. Axint keeps the agent focused on the feature shape, then emits the Apple-facing pieces and writes the repair artifact when something is missing.
intent LogWorkout {
title: "Log workout"
description: "Record a workout with HealthKit."
domain: "health"
param workoutType: string {
description: "Workout type"
}
param durationMinutes: int {
description: "Duration in minutes"
}
}Generated outputs
AX114 - HealthKit entitlement declared without matching privacy usage descriptions.
Next step:
Add NSHealthShareUsageDescription and NSHealthUpdateUsageDescription, then rerun validation.Why a compiler, not another prompt?
Prompts can ask a model to produce Apple-native code. A compiler can normalize the feature, emit the required Swift and metadata, run Apple-specific checks, and produce a stable repair artifact.
The point is not hiding Swift. The point is keeping agents inside a smaller, typed, repeatable loop until the generated Swift is ready to inspect and ship.
The proof only matters if it explains the workflow.
The numbers are not decoration. They explain why agents need a smaller input, why the checks need names, and why the project has enough surface area to be credible.
Smaller authoring surface
Public samples show 69% less definition overhead and 3.3x average compression on the benchmark page. The point is less generated code to resend, diff, and debug.
Apple-specific validation
Named findings let the next agent run act on a scoped correction instead of a pasted build log.
Public receipts
These values come from the public truth layer used by the site, docs, and README.
Built for the people who have to make agent output shippable.
Agent builders
Give Codex, Claude, Cursor, Xcode helpers, and MCP clients a smaller Apple-native contract to work against.
Apple app teams
Add Siri, Shortcuts, Spotlight, widgets, and App Intents without hand-maintaining every boilerplate edge.
Review-heavy teams
Replace pasted Xcode logs with named findings, Fix Packets, and repeatable validation history.
What Axint is not.
Clear boundaries make the thesis easier to trust. Axint emits ordinary Swift at the boundary.
Compiler, agent layer, Cloud, and Registry each have a job.
Axint gives agent-built Apple features one stable path: define the feature, generate the Swift, check the output, repair from the same facts, and reuse the parts that work.
Compiler
The open-source core turns compact definitions into Apple-native Swift and local repair artifacts without requiring a hosted service.
Agent layer
MCP exposes compile, validate, fix, scaffold, schema compile, templates, and repair-packet access where agents already work.
Cloud Check
Free checks give a quick hosted result. Signed-in Pro checks add the repair prompt, history, and a shareable record when the feature needs another pass.
Registry
Packages make repeatable Apple capabilities installable, inspectable, and tied back to compiler metadata instead of copied from scattered snippets.
Apple is expanding the surface area where app functionality can appear.
App Intents make app functionality available across system experiences such as Siri, Shortcuts, Spotlight, widgets, and related Apple Intelligence surfaces. These are not just screens. They are typed, callable contracts.
Apple is also highlighting agentic coding in Xcode. That makes the missing layer clearer: not another model, but a compiler, validation, and repair system that keeps agents grounded in Apple-native rules.
That is the purpose of Axint as a system. The compiler creates the contract; Cloud checks and repairs the output; Registry makes reusable capabilities installable when the work is ready to travel.
Start with a check. Then inspect the compiler and proof.
If you already have Apple-facing output, Cloud Check gives you the fastest feel for the loop. If you want the deeper case, start with the repo, docs, and Fix Packet.