Kawnix
CapabilitiesDocsDashboardConsole
Log in
Kawnix
PrivacyTermsContact
© 2026 Kawnix. All rights reserved.
Documentation

Documentation that explains the system in plain language.

This page is meant to help users understand how Kawnix works as an API provider, an agentic execution layer, and a dynamic connector platform.

What users should learn

How to discover capabilities, authenticate, invoke actions, and verify outcomes.

API first

Clear routes and scoped keys

Agent ready

Structured prompts and workflows

Connector based

Extensible provider integrations

Billing aware

Usage-linked settlement and receipts

Security first

Scoped auth and auditability

Guide

Documentation map

API-based systemAgentic systemDynamic connectorsBillingSecurity

Quick start

New users should begin with discovery, then authenticate, invoke, and review.

Quick start

A simple flow users can follow the first time they integrate Kawnix.

1. Discover

Start with the public manifest registry to understand what a provider exposes and which scopes are required.

2. Authenticate

Create a scoped API key or use the appropriate session context for the workspace.

3. Invoke

Send a structured request to the gateway and let Kawnix handle authorization, routing, and settlement.

4. Review

Inspect receipts, logs, and settlement status so users can verify what happened.

Built for direct API consumption

Kawnix exposes endpoints that teams can call from apps, services, and SDKs. The goal is to make integration feel like any other modern API provider: clear routes, scoped credentials, predictable responses, and receipts you can inspect later.

What this means

  • Use API keys for server-to-server access and scoped permissions.
  • Discover manifests before invoking a capability.
  • Track receipts and settlement outcomes for every call.

Example flow

GET /api/discovery/manifests
POST /api/gateway/invoke
GET /api/receipts/{receiptId}

Designed for autonomous agents and workflows

The agentic layer lets an AI or workflow agent discover capabilities, select the right manifest, and execute actions with guardrails. That keeps the experience understandable for users while still enabling automation.

What this means

  • Agents can read manifests to understand constraints and pricing.
  • Execution is tracked with audit logs and receipts.
  • Provider and consumer roles stay separate by design.

Example flow

1. Read manifest metadata and required scopes.
2. Prepare a structured action request.
3. Submit the request and review the resulting receipt.

Connect new providers without changing the core flow

Dynamic connectors allow Kawnix to attach new provider types, transport layers, or external integrations while keeping the same user-facing model. That makes the platform easier to extend as new API surfaces appear.

What this means

  • Connectors map external capabilities into the manifest registry.
  • New provider types can be added without rewriting consumer flows.
  • The same discovery and invocation patterns still apply.

Example flow

Connector discovery -> manifest sync -> invocation -> receipt
Provider-specific transport stays hidden behind the connector
Consumer UX remains consistent across integrations

Billing is tied to usage, not guesswork

Kawnix makes billing easier to understand by showing the estimate, reserving funds, and finalizing settlement after execution. That keeps users aligned on what will be charged and why.

What this means

  • Show a billing estimate before the request is executed.
  • Reserve funds when the workflow needs payment protection.
  • Confirm or refund the payment after the outcome is known.

Example flow

POST /api/billing/estimate
POST /api/billing/reserve
POST /api/billing/wallet/confirm

Security controls protect each workspace and call

Security is built into the platform with scoped API keys, role-based access, and auditable execution. Users can understand who can call what, and operators can trace each action back to a session or credential.

What this means

  • Use scoped API keys for machine access instead of broad shared secrets.
  • Keep provider and consumer roles separated.
  • Audit logs and receipts make every action traceable.

Example flow

Create API key with limited scopes
Require auth before gateway invocation
Review audit log entries and receipts

Need the API surface next?

Point users to the console or connect them to the workspace they need.

Open consoleCreate account