Inside AGKit

Your application.
A new way to use it.

Connect the tools and context your app already has. AGKit coordinates the AI conversation and tool calls; Cloud supplies the models and operating controls. Your app decides how changes reach its users.

Start building ↗Choose your platform

A request becomes
work in your app.

Built for teams whose applications have real state to work with: documents, timelines, recordings, tasks, and more.

A person asks
“Shorten the opening and lower the music.”
The turn takes shape
Stream the response, validate tool calls, and coordinate the next step.
The model is resolved
Use your profile, model route, provider credentials, and usage limits.
The app does the work
Run your edit functions, request approval, and publish an accepted change.

Tool results return to the runtime for the next model response. A turn can include several calls before the task is complete.

A small surface
into your application.

Start with one useful action. Add more tools as you decide what AI should be able to do in your product.

Describe your tools. Give each operation a name, an input schema, and an implementation that calls your existing app logic.
Supply useful context. Share the selection, document state, or recording the request needs. Keep unrelated app data out.
Connect your Cloud project. Configure a profile and intent tier, then supply project and user authentication in your app.
Build the experience. Show progress, surface approvals and errors, and decide when a proposed change becomes committed state.

Swift · application tool example

“Lower the volume to 50%.”

editor.set_volume{ "volume_percent": 50 }

case "editor.set_volume":
    guard let percent = call.arguments[
        "volume_percent"
    ]?.doubleValue else {
        throw EditorError.invalidEdit
    }

    try attempt.setVolume(percent / 100)

Audio volume100% → 50%

The tool calls the app’s existing volume function on an isolated draft. The host checks the current revision before applying it.

Tool definition and request lifecycle

EditorTools.swift · describe the operation

ToolDefinition(
    id: "editor.set_volume",
    description: "Prepare volume attenuation, 0 through 100 percent; never boost.",
    parameters: .object(
        properties: ["volume_percent": .init(schema: .number)],
        required: ["volume_percent"]
    )
)

EditorRunner.swift · send, check, apply

try await session.send(
    attempt.context + "\nRequest: " + String(prompt.prefix(4000))
)
try Task.checkCancellation()
try store.publish(attempt)

Excerpts from the private Swift reference app, which also registers the tools and configures guards, limits, and confirmation handling.

Connect the same tools to Cloud.

The app names a profile and the balanced tier. Cloud resolves the configured model. The example’s setup supplies the endpoint and authenticated signer.

LiveConnection.swift · Cloud provider configuration

let provider = BackendRouterProvider(
    endpoint: endpoint,
    mode: .cloudProfile(BackendRouterCloudProfile(
        agentId: profile,
        tier: "balanced",
        maxOutputTokens: 1024,
        signer: signer
    ))
)

Illustration: a proposed edit waits for review, then is approved. A separate proposal is cancelled and its draft discarded. The sequence repeats.

AI proposes.
Your app stays in control.

The runtime coordinates streaming, tool validation, execution, and follow-up responses. Connect guards and confirmation handling to your application’s permission rules, and give users a way to cancel work in progress.

Your app owns the actual operations, approval interface, and undo implementation. For shared or irreversible actions, decide what requires confirmation and what can be recovered.

Choose your integration path →

Review before publication

Prepare changes in a draft. Let the user approve the exact work your application is about to publish.

Keep manual changes safe

Check the current document revision before committing an AI edit. Reject a stale proposal instead of overwriting newer work.

Make undo meaningful

Connect your application’s undo behavior to the transaction lifecycle. A local undo cannot recall a copy somebody has already shared.

Ship the app.
Keep improving its AI.

AGKit Cloud is the shared backbone for your integrations. Adjust the configuration behind an existing app’s requests from one place.

Models: Rebind an intent tier to a configured provider and model. The app keeps requesting the same tier.
Agent behavior: Update profile instructions, enabled tool schemas, and request limits. Keep schemas compatible with the tools installed in the app.
Credentials: Manage provider credentials and trusted user issuers centrally, with provider keys kept out of your app.
Spending: Set project and per-user usage controls. Inspect usage as your product grows, and adjust limits to match it.
Media: Configure the provider behind a media capability and bind voice identities such as narrator to a compatible voice.

These configuration changes do not require an app release. Adding a new application tool or changing how it edits your data still belongs in your application code.

See plans and provider costs →

Know the user.
Control the usage.

Use your existing authentication to identify the person making a Cloud request. Configure trusted token issuers in AGKit; Cloud verifies the token before accepting the user’s identity.

Attribute each request

Cloud usage records associate a hashed user identifier with the request, model, token counts, estimated cost, duration, and outcome. Follow usage per user without putting a raw user ID in the usage ledger.

Enforce per-user limits

Set daily turn limits, monthly token limits, request rates, and monthly spending caps for your project’s users. Cloud checks usage and budgets before admitting further requests.

Gate subscriber access

Connect RevenueCat and choose a required entitlement. Cloud checks that the user has active access before running a request. Per-user quotas apply across the project; separate quota amounts for individual subscription plans require your own plan logic.

The right provider.
For each capability.

Connect the providers your app needs. Manage language models and media routes through the same AGKit Cloud project.

Integrations available through AGKit Cloud
Provider	Language	Images	Voice & audio	Video
OpenAI	Models + tools	Generate + edit	Speech + transcription	—
Anthropic	Models + tools	—	—	—
Google Gemini	Models + tools	Generate + edit	Speech	Veo
xAI	Models + tools	Generate + edit	Speech + transcription	Grok
ElevenLabs	—	—	Speech, transcription, music + sound effects	—

Availability depends on your model and route. Image and video entries describe media creation; a dash means AGKit has no integration for that capability.

Add more ways
to create and understand.

Combine application tools with media capabilities. Cloud routes each request to a configured provider that supports it.

Generate an image

Add a prompt-to-image action to a document or creative workspace. Your app requests image generation; Cloud supplies the configured route, and your app decides where to place the result.

Give your app a voice

Read a lesson or narrate a scene with a named voice identity. Rebind narrator in Cloud while your app keeps using the same name.

Work with recordings

Send supported audio to an audio-capable route for transcription or summarization. Combine the result with your app’s tools to prepare notes and tasks for review.

Choose your integration →

Keep Cloud operations
in your workflow.

Create projects, configure agents and tools, manage model and media routes, and set usage limits from your terminal or AI assistant.

Set up and inspect from the CLI

Sign in, verify your account, then use the guided project setup. Inspect the proposed changes before applying configuration to live traffic.

agkit login
agkit whoami
agkit init

Manage Cloud through your assistant

Connect the local MCP server to read configuration and usage, create and update resources, and apply changes. Writes use reviewable plans, permissions are checked when they are applied, and applied changes appear in the audit log.

agkit mcp print-config

After CLI sign-in, use the generated configuration in your MCP client. Grant the read and write scopes your workflow needs.

Local MCP can apply supported configuration changes without a dashboard visit. Sign-in, billing, account security, key issuance, and some credential operations use dedicated CLI or browser steps. Remote MCP writes require approval in the dashboard.

Get the tooling and setup path →

Your app.
Any screen.

Build for Swift, Android, React Native, and Web, with a shared Cloud backbone for models, configuration, and spending.

Swift

Apple apps

Give AI access to your app’s tools and state, with an integration that fits your Swift code.

Android

Native Android

Connect AI to native app capabilities while keeping the experience in your app’s hands.

React Native

Cross-platform mobile

Add AI-powered actions to your iOS and Android apps with React Native.

Web

Web apps

Connect AI to your web app’s tools and state, with models and configuration managed in AGKit Cloud.

Start with one useful action.

Choose your platform, connect your project, and build from there.

Start building Choose your platform

A request becomeswork in your app.

A person asks

The turn takes shape

The model is resolved

The app does the work

A small surfaceinto your application.