Android (Gemini) and iOS (Siri / Apple Intelligence) are converging on the same idea: apps expose structured, self-describing functions that on-device AI agents can discover and invoke. Android calls it AppFunctions; Apple calls it App Intents. The two APIs are conceptually identical — annotated function + typed params + description + entity types — but completely incompatible in implementation. So a KMP team today writes and maintains two parallel capability layers.

Kapability collapses that into one. A Gradle plugin + KSP processor + thin runtime that turns a single @Capability declaration in commonMain into native glue for both platforms at build time.

[!NOTE] Status: early / pre-release. Proven end-to-end on both platforms; while pre-1.0 the public API may still change. (Current version: the Maven Central badge above.)

• 🎯 Declare once, ship both — one annotated function in commonMain, native on Android and iOS.
• 🔌 Zero hand-written glue — the @AppFunction wrapper, @AppFunctionSerializable types, the Swift AppIntent + AppEntity, and the dispatch bridge are all generated.
• 🏗️ Official toolchains — feeds Google's androidx.appfunctions compiler and Xcode's App Intents extraction; no reimplemented metadata formats.
• 🧭 Graceful asymmetry — @Capability(platforms = [ANDROID]) for platform-specific capabilities.
• 🛡️ Fail fast — unsupported types stop the build with a clear message instead of mis-generating.
• ⚙️ One line of setup — plugins { id("dev.kotforge.kapability") }.

Artifacts are on Maven Central and the plugin is on the Gradle Plugin Portal, so the default repositories are enough:

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

Your KMP module (where capabilities live):

// shared/build.gradle.kts
plugins {
    kotlin("multiplatform")
    id("com.android.library")
    id("co.touchlab.skie")                       // required: Kotlin suspend -> Swift async bridge
    id("dev.kotforge.kapability") version "0.2.0"
}

Your Android app module:

// androidApp/build.gradle.kts
plugins {
    id("com.android.application")
    kotlin("android")
    id("dev.kotforge.kapability") version "0.2.0"
}

kapability {
    capabilityProject.set(project(":shared"))
}

That's it — the plugin adds the kapability-annotations / kapability-runtime dependencies, wires the KSP processor + the androidx.appfunctions two-pass, and manages the generated sources for you.

Write this once, in commonMain:

import dev.kotforge.kapability.annotations.*

@CapabilityEntity(description = "A note in the app")
data class Note(
    @CapabilityId val id: String,
    val title: String,
    val content: String,
    val priority: Int,
)

class NoteCapabilities(private val repo: NoteRepository) {

    @Capability(description = "Create a note with the given title, content and priority")
    suspend fun createNote(
        @CapabilityParam(description = "Title of the note") title: String,
        @CapabilityParam(description = "Body content of the note") content: String,
        @CapabilityParam(description = "Priority from 1 (low) to 5 (high)") priority: Int,
    ): Note = repo.create(title, content, priority)
}

…and Kapability generates, at build time:

Both dispatch through one generated KapabilityRuntime.invoke() entry point into your shared code. Wire your capability instance once at startup (KapabilityRuntime.install(NoteCapabilities(repo))), and you're done.

        commonMain: @Capability
                 │  Kapability KSP processor
                 ▼
   ┌──────────────────────────────────────────────┐
   │  generated KapabilityRuntime.invoke() (common) │
   └───────────────┬────────────────┬──────────────┘
      Android glue  │                │  iOS glue
    @AppFunction    │                │  Swift AppIntent
  @AppFunctionSerializable           │  AppEntity  (SKIE async)
                 ▼                    ▼
     androidx.appfunctions       App Intents runtime
        (Gemini)                 (Siri · Shortcuts · Spotlight)

What each on-device platform supports natively, and what Kapability carries today — as parameters and @CapabilityEntity properties, returning a @CapabilityEntity. Values travel across a JSON bridge; anything Kapability doesn't support fails the build with a clear error.

Legend: ✅ supported · 🕓 planned (roadmap) · ⚠️ supported with caveats · ❌ not supported by the platform

¹ androidx.appfunctions 1.0.0-alpha08 rejects arbitrary enums — Kapability bridges the gap by surfacing an enum as its String name on Android (a real AppEnum on iOS), so it works on both. ² AppFunctions models numeric collections as primitive arrays (IntArray, DoubleArray, BooleanArray), not List<T>. ³ Native platform support expected but not yet verified against alpha08.

The Android column reflects androidx.appfunctions 1.0.0-alpha08.

samples/notes is a full KMP app that consumes the published SDK from a separate Gradle build (proving the external-consumer path) and runs on both an Android 16+ emulator (adb shell cmd app_function execute-app-function) and the iOS simulator (App Intents test).

• Richer types: Date, non-String lists (via primitive-array mapping), nested @CapabilityEntity + List<CustomObject>
• Reduced consumer wiring (generate the appfunctions Provider; register once in commonMain)
• manifest.json + a verifyKapability drift-detection task
• Local Swift Package emission for iOS distribution
• v0.2+: schema conformance, entity queries / Spotlight, interaction donations

Kapability uses Conventional Commits + release-please. Commit / squash-merge titles drive the next version:

On merge to main, release-please maintains a release PR (version + CHANGELOG.md). Merging it tags and publishes to Maven Central + the Gradle Plugin Portal automatically.

Copyright 2026 Piyush Sinha

Licensed under the Apache License, Version 2.0 — see LICENSE.