Open SDK · Waitlist

Open SDK: Build your own agentic apps

Build apps for business processes that currently get stuck between systems, data, and approvals. Builders focus on process and app logic; the platform handles the infrastructure underneath.

Join waitlist See the quickstart ↗

For partners, developers, and teams building production-grade agentic apps.

Inspiration

What your own agentic apps could look like.

Use these apps as inspiration for how interface, process logic, AI behavior, and domain knowledge can become one controllable business process.

Documents · approval · M365 · lexoffice

Office Assistant

A request, sketch, or email becomes a finished quote.

The app connects UI, document logic, customer data, approvals, and delivery. The agent prepares the draft, the human approves.

Vision · audio · PDF · WhatsApp

Expert report app

Photos and audio become a reviewable report.

Analyze images, structure damage, sort evidence, prepare reports, and resolve follow-up questions in the same workflow.

Odoo · Business Central · reports · audit

Finance Assistant

Numbers become forecasts and management briefings.

Accounting, cash flow, open items, and operational KPIs come together in one controllable process.

Open SDK · custom UI · domain logic

Your industry app

Build the process standard software never captures well.

Define your own interface, process logic, AI behavior, and domain knowledge with the Open SDK or together with Linkworld.

Why Linkworld

Do not rebuild the platform underneath your app.

Teams want to build AI apps, not spend months building infrastructure for security, multi-LLM, governance, hosting, and operations. Linkworld provides that layer so builders can move from use case to production app faster.

No custom AI infrastructure

Teams want to build AI apps, not spend months assembling runtime, model access, tool connections, and operations.

No security and governance project

Approvals, audit, access control, and critical actions are part of the platform before an app reaches production.

No operations platform per customer

Customer environments, credentials, channels, logs, and recovery use one shared platform layer instead of one-off projects.

Anatomy of a Linkworld App

Four layers. One business process.

A Linkworld App connects manifest, workflows, tools, and system integrations into one controllable business process. The agent works inside clear rules, permissions, and approvals.

Manifest

declarative

One file describes what the app is, which triggers and intents it knows, and which skills it needs.

Workflows

rule-based

Signature flows define tool sequences with hard rules: look up prices, create documents, render PDFs, request approval.

Tools

skill-gated

The agent only sees tools the tenant is allowed to use: documents, PDFs, email, WhatsApp, ERP, or domain functions.

Channels · systems

transparent

WhatsApp, web, voice, Odoo, Business Central, or lexoffice stay interchangeable. The workflow remains the same.

Agentic app, not chatbot.

Users do not write perfect prompts. The app knows the process, data, tools, approvals, and target state. The agent executes, but inside a controlled app frame.

Example

Office Assistant — five workflows.

A concrete app model from the platform: five business processes, clear tool steps, and approvals without building your own process engine.

custom_quote_from_positions

User dictates line items → quote

photo_or_sketch_to_quote

Photo/sketch → damage detection → quote

letter_or_protocol

Letters/minutes, pure template-based

show_existing_document

Show an existing document in the current channel

send_document_via_email

Send a document to an email — with approval gate

Quickstart

5 minutes from zero to deploy.

CLI, scaffold, develop locally, log in, deploy. Mock backends ship with the SDK; no cloud account needed to build.

01
Install the CLI
```
$pip install linkworld
```
02
Scaffold an app
```
$linkworld init my-app --lang typescript --github-owner you
```
Generates a starter project, handler skeleton, Dockerfile, and GitHub Actions CI.
03
Develop locally
```
$cd my-app
npm install
npm run dev
```
Mock backends for local system and secret calls ship with it. No cloud account needed while coding.
04
Log in with GitHub
```
$linkworld login
```
05
Deploy
```
$git tag v0.1.0 && git push --tags
```
CI builds the image, pushes to GHCR, registers the version. Visible in the dev console immediately.

Alternative to quickstart

Let your coding agent handle setup and the first app.

Copy the prompt into Claude Code, Cursor, or your coding agent. It installs what is needed for Linkworld SDK apps, uses docs.linkworld.ai as reference, and prepares the app for the test console and marketplace.

linkworld-app-builder.prompt

You are my coding agent in Claude Code, Cursor, or a comparable agentic IDE.

Goal: Set up my development environment and build a first working Linkworld App with the Open SDK.

Context:
- Linkworld Apps turn concrete business processes into agentic apps.
- I focus on the process, app logic, data model, UI, and domain rules.
- Linkworld handles execution, multi-LLM, tenant isolation, credentials, tools, security gates, approvals, observability, and deployment underneath.
- The app should run in the Linkworld test console and optionally be packaged for the marketplace.
- Official docs live at https://docs.linkworld.ai/. An LLM-optimized entry point is at https://docs.linkworld.ai/llms.txt.

IMPORTANT — before making architectural decisions, read the Developer Patterns:
https://docs.linkworld.ai/developer/patterns/
For each common use case (storing credentials, multi-step workflows, reacting to emails, cross-app events, integrating non-platform services, sending at scale) the pattern docs name the right Linkworld primitive plus explicit anti-patterns with reasoning. Generic answers ("state machine for cadences", "while-True polling", "API key in KV") are wrong on Linkworld — the platform has first-class primitives for these (heartbeats, on_inbound + grants/wires, ctx.secrets, ctx.events.emit). When unsure which primitive fits, the answer is in the pattern docs.

Workflow:
1. First inspect what is installed locally: Node.js, npm/pnpm, Python/pip, Git, Docker, GitHub CLI, and the Linkworld CLI/SDK.
2. Install or update everything needed to develop Linkworld SDK apps. Use the official docs at https://docs.linkworld.ai/ as the source of truth.
3. Read the Developer Patterns overview at https://docs.linkworld.ai/developer/patterns/ before designing the app's architecture.
4. Ask for the business process, target users, input channels, required systems, data sources, and approvals if that context is missing.
5. Scaffold the app with the Linkworld SDK:
   linkworld init <app-name> --lang typescript --github-owner <github-owner>
6. Define the app model, manifest, handlers, workflows, required tools, permissions, and human-in-the-loop approvals — aligned with the relevant patterns. Verify manifest fields and tool signatures against the SDK reference, do not extrapolate.
7. Implement the most important happy path with local mocks for tool and secret calls. Credentials go through ctx.secrets, not ctx.kv. Cadences run via manifest heartbeats, not while-True loops. External API keys come from install_settings + ctx.secrets.get(), not from env or hardcoding.
8. Run `linkworld lint`. Fix all LWP findings (LWP001 blocks deploy; LWP002-005 are warnings/info). Each lint issue links the matching pattern doc as the canonical fix. Use `# lwp:ignore=LWPxxx` (Python) / `// lwp:ignore=LWPxxx` (TypeScript) only for real false positives with a justifying comment.
9. Add tests or verification steps for real sample data and critical edge cases.
10. Create a short README with setup, local testing, test-console deploy, relevant docs links, and marketplace checklist.
11. Keep the implementation clear, tenant-safe, and auditable. Do not put real API keys into code or tests.

Start with the setup check. If something is missing, install it or give me the exact command. Once there is enough context, read the patterns overview first and then create files.

From idea to production

A clear path from process idea to running app.

The path to production stays business-led: clarify the process, model the app, test with real data, collect approvals, and roll out with control.

01
Define the business process
Which process should run as an app, who will use it, and what outcome has to be produced?
02
Model the AI app
Roles, data, approvals, and channels are described as an app model before implementation starts.
03
Test with real data
The app is tested against real examples, documents, and edge cases, not only demo prompts.
04
Review and approvals
Business, IT, and security review behavior, permissions, and critical actions before rollout.
05
Roll out to teams or customers
The app is released in a controlled way and improved while it runs in production.

Enterprise infrastructure

What the platform takes off your plate.

Linkworld turns an app idea into an operable AI workflow: isolated per customer, securely connected, observable, and deliverable across models and channels.

Freely chosen models per workflow step

Claude, GPT, Gemini, Mistral, Llama, and DeepSeek are built in. Teams choose the right model per agent, skill, or process step.

Isolated customer environments without custom infrastructure

Every app runs tenant-separated with isolated data, credentials, and customer-specific configuration.

Approvals and audit trails for critical actions

Risk-based approval flows, human-in-the-loop, and traceable system use are part of production operations.

Secure tool and system connections

100+ system integrations, encrypted credentials, and controlled permissions connect apps with Microsoft 365, Odoo, Lexoffice, GitHub, and more.

Delivery through WhatsApp, web, voice, or desktop

One shared backend can serve multiple channels, so apps are available where teams already work.

Monitoring and recovery for production AI workflows

Structured logs, metrics, cost control, and automatic recovery for interrupted jobs keep workflows operable.

SDKs

Build in Python or TypeScript.

Both SDKs use the same app contract and runtime environment. You choose the language, Linkworld provides the framework.

Coding with Cursor, Claude Code, or Codex? Start with the Developer Patterns — they give you the right architectural choice per use case and catch common mistakes before deploy via linkworld lint.

Pythonlinkworld.app.py

from linkworld_sdk import App

app = App.from_manifest("linkworld.app.yaml")

@app.on_inbound
async def on_inbound(ctx, env):
    if env.channel != "email":
        return
    # Reply patterns + thread resolution:
    # docs.linkworld.ai/developer/patterns/reacting-to-emails/
    ctx.logger.info(
        f"From {env.sender_name}: {env.message_text[:80]}"
    )

Python reference →

TypeScriptlinkworld.app.ts

import { App } from '@linkworld/sdk'

const app = App.fromManifest('linkworld.app.yaml')

app.onInbound(async (ctx, env) => {
  if (env.channel !== 'email') return
  // Reply patterns + thread resolution:
  // docs.linkworld.ai/developer/patterns/reacting-to-emails/
  ctx.logger.info(
    `From ${env.sender_name}: ${env.message_text.slice(0, 80)}`
  )
})

await app.run()

TypeScript reference →

Marketplace planned

Market your apps in the Linkworld Marketplace.

Linkworld is designed to help builders and integrators not only develop apps, but also package, publish, and eventually sell agentic apps for companies.

Make apps discoverable

Publish reviewed agentic apps in the planned Linkworld Marketplace so companies can find and request them.

Package for enterprise buyers

App, positioning, target audience, required systems, and approvals are prepared so customers understand what they are buying faster.

Sell recurring apps later

Subscription models are planned for builders, integrators, and partners who want to offer industry apps at scale.

Open SDK · Waitlist

Ready to build?

Join the waitlist now. Choose “Build apps with the SDK” and describe the app you want to build or later offer in the marketplace.

Join the waitlist

Queue by fit and capacity

SDK access, starter project, and dev console

Deploy through the test console

Deploy to the marketplace

Join waitlist

Open SDK: Build your own agentic apps

Office Assistant

Expert report app

Finance Assistant

Your industry app

No custom AI infrastructure

No security and governance project

No operations platform per customer

Manifest

Workflows

Tools

Channels · systems

Install the CLI

Scaffold an app

Develop locally

Log in with GitHub

Deploy

Define the business process

Model the AI app

Test with real data

Review and approvals

Roll out to teams or customers