The Foundation Models framework provides access to Apple's on-device Large Language Model (3 billion parameters, 2-bit quantized) with a Swift API. This reference covers every API, all WWDC 2025 code examples, and comprehensive implementation patterns.
Fetches axiom-foundation-models-ref from charleswiltgen/axiom and configures it for Cursor.
3
Select Cursor when prompted
The CLI shows a list of agents. Use arrow keys and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ────────────────
│ · Cline · Codex · Goose · Windsurf
│ ●Cursor(selected)
│ · Cursor · Aider · Continue
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/axiom-foundation-models-ref
Restart Cursor to activate axiom-foundation-models-ref. Access via /axiom-foundation-models-ref in your agent's command palette.
⚠
Security Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.
Foundation Models Framework — Complete API Reference
Overview
The Foundation Models framework provides access to Apple's on-device Large Language Model (3 billion parameters, 2-bit quantized) with a Swift API. This reference covers every API, all WWDC 2025 code examples, and comprehensive implementation patterns.
Model Specifications
3B parameter model, 2-bit quantized, 4096 token context (input + output combined). Optimized for on-device summarization, extraction, classification, and generation. NOT suited for world knowledge, complex reasoning, math, or translation. Runs entirely on-device — no network, no cost, no data leaves device.
When to Use This Reference
Use this reference when:
Implementing Foundation Models features
Understanding API capabilities
Looking up specific code examples
Planning architecture with Foundation Models
Migrating from prototype to production
Debugging implementation issues
Related Skills:
axiom-foundation-models — Discipline skill with anti-patterns, pressure scenarios, decision trees
axiom-foundation-models-diag — Diagnostic skill for troubleshooting issues
LanguageModelSession
Overview
LanguageModelSession is the core class for interacting with the model. It maintains conversation history (transcript), handles multi-turn interactions, and manages model state.
let session =LanguageModelSession(instructions:"""
You are a friendly barista in a pixel art coffee shop.
Respond to the player's question concisely.
""")
From WWDC 301:1:05
With Tools:
let session =LanguageModelSession( tools:[GetWeatherTool()], instructions:"Help user with weather forecasts.")
From WWDC 286:15:03
With Specific Model/Use Case:
let session =LanguageModelSession( model:SystemLanguageModel(useCase:.contentTagging))
From WWDC 286:18:39
Instructions vs Prompts
Instructions:
Come from developer
Define model's role, style, constraints
Mostly static
First entry in transcript
Model trained to obey instructions over prompts (security feature)
Prompts:
Come from user (or dynamic app state)
Specific requests for generation
Dynamic input
Each call to respond(to:) adds prompt to transcript
Security Consideration:
NEVER interpolate untrusted user input into instructions
User input should go in prompts only
Prevents prompt injection attacks
respond(to:) Method
Basic Text Generation:
funcrespond(userInput:String)asyncthrows->String{let session =LanguageModelSession(instructions:"""
You are a friendly barista in a world full of pixels.
Respond to the player's question.
""")let response =tryawait session.respond(to: userInput)return response.content
}
From WWDC 301:1:05
Return Type: Response<String> with .content property
respond(to:generating:) Method
Structured Output with @Generable:
@GenerablestructSearchSuggestions{@Guide(description:"A list of suggested search terms",.count(4))var searchTerms:[String]}let prompt ="""
Generate a list of suggested search terms for an app about visiting famous landmarks.
"""let response =tryawait session.respond( to: prompt, generating:SearchSuggestions.self)print(response.content)// SearchSuggestions instance
From WWDC 286:5:51
Return Type: Response<SearchSuggestions> with .content property
Generation Options
See Sampling & Generation Options for GenerationOptions including sampling:, temperature:, and includeSchemaInPrompt:.
Multi-Turn Interactions
Retaining Context
let session =LanguageModelSession()// First turnlet firstHaiku =tryawait session.respond(to:"Write a haiku about fishing")print(firstHaiku.content)// Silent waters gleam,// Casting lines in morning mist—// Hope in every cast.// Second turn - model remembers contextlet secondHaiku =tryawait session.respond(to:"Do another one about golf")print(secondHaiku.content)// Silent morning dew,// Caddies guide with gentle words—// Paths of patience tread.print(session.transcript)// Shows full history
From WWDC 286:17:46
How it works:
Each respond() call adds entry to transcript
Model uses entire transcript for context
Enables conversational interactions
Transcript Property
let transcript = session.transcript
for entry in transcript.entries {print("Entry: \(entry.content)")}
Use cases:
Debugging generation issues
Displaying conversation history in UI
Exporting chat logs
Condensing for context management
isResponding Property
Gate UI on session.isResponding to prevent concurrent requests:
@Generable enables structured output from the model using Swift types. The macro generates a schema at compile-time and uses constrained decoding to guarantee structural correctness.
Basic Usage
On Structs:
@GenerablestructPerson{let name:Stringlet age:Int}let response =tryawait session.respond( to:"Generate a person", generating:Person.self)let person = response.content // Type-safe Person instance
›Access to product documentation and roadmap tools (Jira, Notion, etc.)
›Understanding of product management frameworks (RICE, Jobs-to-be-Done, etc.)
›Stakeholder contact information and communication channels
Time Estimate
30-60 minutes to see productivity improvements
Steps
1Install product management skill
2Start with user story generation for known feature
3Progress to competitive analysis: research 2-3 competitors
4Use for roadmap prioritization: apply RICE/ICE scoring
5Draft stakeholder communications and refine based on feedback
6Build template library for recurring PM tasks
7Share effective prompts with product team
Common Pitfalls
⚠Not validating competitive research—verify facts before sharing
⚠Accepting user stories without involving engineering team
⚠Over-relying on frameworks without qualitative judgment
⚠Not customizing outputs to company culture and communication style
⚠Skipping stakeholder validation of generated requirements
Best Practices
✓ Do
+Validate research and competitive analysis with real data
+Collaborate with engineering when generating technical requirements
+Customize frameworks and templates to your company context
+Use skill for first drafts, refine with stakeholder input
+Document successful prompt patterns for PM tasks
+Combine AI efficiency with human judgment and intuition
✗ Don't
−Don't publish competitive analysis without fact-checking
−Don't finalize user stories without engineering review
−Don't make prioritization decisions solely on AI scoring
−Don't skip customer validation of generated requirements
−Don't ignore company-specific context and culture
💡 Pro Tips
★Provide context: company goals, constraints, customer feedback
★Ask for alternatives: 'Show 3 ways to prioritize this roadmap'
★Request stakeholder-specific formatting: 'Executive summary vs. engineering spec'
★Use skill for 70% generation + 30% customization to company needs
When to Use This
✓ Use when
Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.
✗ Avoid when
Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.
Learning Path
1Basic: user stories, feature specs, status updates
