Powerful possibilities.
A clear way in.

Your best skill deserves
more than one computer.

Bring a SKILL.md bundle authored in Claude or Codex into Klaudija. Turn its instructions, reference files, templates, and scripts into a reusable MOD that your agents can work with.

The MOD library

Explore the screen

1. 01

   Package the expertise.

   Include SKILL.md and the scripts, templates, images, and reference material it needs. A downloadable converter also helps prepare bundles in Cowork or Claude Code.

2. 02

   Import and inspect.

   Upload in MODs. Klaudija normalizes common export packaging issues and checks the bundle. If its identity already exists, choose a new version or a separately named skill.

3. 03

   Review with AI assistance.

   Read compatibility findings first. The optional AI converter proposes changes to instructions and supporting text. Inspect the diffs, preserved assets, and remaining manual issues before applying them.

4. 04

   Prepare it for real work.

   Review credential findings and runtime requirements, publish the reviewed bundle, and attach it to an agent. Test a representative task in a development session, including the generated files.

Review before publishing

Explore the screen

Build the team
your business needs.

Give each agent a role, instructions, a model, tools, and the right MODs. Create a coordinator that routes work to selected specialists, each working in its own thread.

Build a specialist roster

Explore the screen

Give expertise
the tools to act.

A skill can do more than read reference material. It can run scripts, create documents, and call the business APIs its workflow needs.

Make Klaudija part
of something bigger.

Keep your brand, product interface, and customer relationship. Configure your platform, connect its identities, and give it agents equipped with the expertise your business needs.

Manage connected platforms

Explore the screen

1. 01

   Configure your platform.

   Register origins, set platform defaults, and choose agent assignments. Platform-scoped operator roles keep administration aligned with the intended product.

2. 02

   Connect customer identities.

   Your backend provisions users and exchanges the platform identity for end-user tokens. Calls from the product use the user token; administrative keys stay on your backend.

3. 03

   Build the customer experience.

   Use the API for conversations, asynchronous jobs, live events, files, history, and usage. Show the opted-in MOD catalogue with product-facing titles and descriptions.

Keep the context
that makes work personal.

Use MODs for reusable expertise and memory stores for useful user context. Keep conversation history and documents connected to the work they came from.

Give every client
a plan that fits.

Assign allowances, billing periods, overrides, and additional credits. Make recorded spend visible to operators and expose a clear usage state inside your product.

User plans and spending

Explore the screen

Know what happened.
Make the next run better.

Trace work from request to deliverable. Inspect sessions, jobs, tool events, files, errors, and costs, with health and latency views to help locate slow or failing operations.

Inspect latency and recovery

Explore the screen

Your first integration.

Use your provisioned API endpoints, a registered application origin, and a user token. The examples below describe the implemented managed-agent API.

Your users. Their scope.

Keep the platform key on your server. It authenticates platform administration through X-Platform-API-Key. Customer-facing calls use Authorization: Bearer <access_token>.

# Run on your backend. Never expose PLATFORM_KEY to a browser.
curl --fail-with-body "$KLAUDIJA_API_BASE/admin/platform-users" \
  -H "X-Platform-API-Key: $PLATFORM_KEY" \
  -H 'Content-Type: application/json' \
  --data '{
    "user_id": "dev_customer_42",
    "platform_slug": "dev_your_platform",
    "email": "dev_customer_42@example.com",
    "plan_code": "YOUR_CONFIGURED_PLAN",
    "provision_memory_store": true
  }'

curl --fail-with-body -X POST \
  "$KLAUDIJA_API_BASE/admin/platform-users/dev_customer_42/auth" \
  -H "X-Platform-API-Key: $PLATFORM_KEY"

The user body needs user_id and platform_slug (or source). Use an existing configured plan. Token exchange needs the user’s email and linked authentication identity.

Canonical business identity may represent a team. Do not assume the returned authentication UUID equals your platform’s customer ID.

One request. Real work.

The body accepts query, session_id, async, and one optional file. Include a query or a file. Keep the same session ID to continue a conversation. Agent selection is resolved by configuration; public callers cannot select arbitrary agents.

# Use your provisioned endpoint and registered application origin.
curl --fail-with-body "$KLAUDIJA_RUN_BASE" \
  -H "Authorization: Bearer $KLAUDIJA_ACCESS_TOKEN" \
  -H "Origin: $KLAUDIJA_REGISTERED_ORIGIN" \
  --form-string 'query=Summarize this document.' \
  --form-string 'session_id=dev_conversation_42' \
  --form-string 'async=1' \
  -F 'file=@document.pdf'

Browser requests carry their origin automatically. Server and cURL integrations must send their registered Origin. Let your HTTP client set the multipart boundary and Content-Length.

{
  "job_id": "example-job-id",
  "session_id": "dev_conversation_42",
  "status": "pending",
  "anthropic_session_id": "example-provider-session",
  "memory_status": "attached"
}

async=1 is essential: the endpoint defaults to synchronous execution. Async acceptance still includes authentication, budget checks, uploads, and session provisioning.

Handle every terminal state.

Poll with the same user JWT. Public statuses are pending, done, error, and cancelled. An error state can arrive with HTTP 200, so always inspect the response body.

// Poll at a bounded interval, with a deadline and cancellation.
// Stopping this client wait does not cancel the agent job.
async function waitForJob(runBase, jobId, accessToken, signal) {
  const boundedSignal = AbortSignal.any([
    signal, AbortSignal.timeout(5 * 60_000)
  ]);
  while (true) {
    boundedSignal.throwIfAborted();
    const response = await fetch(
      `${runBase}/status/${encodeURIComponent(jobId)}`,
      { headers: { Authorization: `Bearer ${accessToken}` }, signal: boundedSignal }
    );
    if (!response.ok) throw new Error(`Status: ${response.status}`);
    const job = await response.json();
    if (job.status === "error") throw new Error(job.error);
    if (["done", "cancelled"].includes(job.status)) return job;
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
  // Preserve the job ID if this client wait times out.
}

On completion, read response and file_download_available. A cancelled job can include partial results. Keep the job ID if your client stops waiting; cancel the server job explicitly through the cancellation endpoint.

Deliver something useful.

The full multipart request is limited to 50 MiB, including overhead. A single file attachment is supported per submission. File names and formats are validated for the configured runtime.

# Check file_download_available first. Result success is binary.
curl --fail-with-body "$KLAUDIJA_RUN_BASE/result/$JOB_ID" \
  -H "Authorization: Bearer $KLAUDIJA_ACCESS_TOKEN" \
  -o result.bin

# Select a specific output belonging to that job:
curl --fail-with-body --get \
  "$KLAUDIJA_RUN_BASE/result/$JOB_ID" \
  -H "Authorization: Bearer $KLAUDIJA_ACCESS_TOKEN" \
  --data-urlencode "file=$FILE_ID" \
  -o selected-output.bin

Successful result responses are binary; errors are JSON. Inspect Content-Type and Content-Disposition instead of assuming a DOCX. An output selector must reference a file recorded on that job. Treat signed download links as temporary bearer credentials.

Let users see the work happen.

Klaudija persists events in juris_session_events and delivers them through Supabase Realtime. The public API has no /stream SSE endpoint.

1. Configure the provisioned Supabase client with the user’s JWT.
2. Subscribe with the authorized job filter job_id=eq.<job_id> and wait for subscription readiness.
3. Fetch existing events to close the gap, then deduplicate by event ID.
4. Render text deltas, tool activity, files, and terminal states.
5. Keep bounded status polling as a recovery path and remove the subscription on teardown.

Filter subscriptions to the current job and preserve the platform’s access policies. Re-subscribe and reconcile after disconnects; receiving a live connection alone does not mean a job completed.

The integration surface.

Paths below are relative to the supplied base. The downloadable OpenAPI describes the public integration subset, with placeholder servers and source-checked contracts.

Build the unhappy path, too.

{
  "error": "Budget limit reached",
  "reason": "budget_exceeded",
  "plan_code": "YOUR_CONFIGURED_PLAN",
  "spent_cents": 10000,
  "plan_cents": 10000,
  "grace_cents": 0,
  "credits_cents": 0,
  "resets_at": "2026-10-01T00:00:00.000Z"
}

Amounts are illustrative account allowances, not Klaudija pricing. Memory can report degraded, not_applicable, or unknown; display memory_warning when provided. Session rollover metadata identifies a successor session.

Keep your business rules close.

Platform administration supports user provisioning, plan changes, credits, and scoped identity exchange. Operator APIs additionally cover agents, skill versions and assets, memory stores, environments, Vault metadata, sessions, usage, rate cards, and audit history.

These surfaces have different permissions. A platform key does not grant global operator authority. Use /me/usage for the user’s budget view; operator plan configuration is a separate administrative responsibility.

Contract review: 5 September 2026. Integration examples checked against source and mocked locally; not executed against production.