SDK Overview

The Komand SDK is an MIT-licensed open-source toolkit for building skills, integrations, and extensions for the Komand platform. While the core platform is licensed under the Business Source License (BSL), the SDK is fully open — enabling a thriving ecosystem of third-party skills without giving away the platform.

Why an Open SDK?

Komand takes the Salesforce AppExchange approach: a proprietary, governed platform with an open ecosystem for extensions. This means:

Anyone can build skills — no license fees or approval required to develop
Publish to the marketplace — reach all Komand users through the curated catalog
Fork and extend — use the SDK in your own projects under MIT
Community-driven — contribute improvements back to the SDK

This is a deliberate contrast to open-source agent frameworks where the entire platform is exposed (and often exploited). Komand keeps the core secure while making the extension surface fully open.

What You Can Build

Skills

Skills are the primary unit of the marketplace. Each skill is a discrete capability that agents invoke during conversations:

CRM integrations — Salesforce, HubSpot, Pipedrive contact lookup and deal management
Communication — email, SMS, push notifications
Scheduling — Google Calendar, Outlook, availability checks
Finance — invoice generation, payment processing, expense tracking
Research — web search, market data, competitor analysis
Document generation — invoices, quotes, contracts
Development tools — GitHub integration, CI/CD triggers
Custom business logic — anything your workflow needs

Channel Adapters

Connect new messaging platforms to Komand. Channel adapters are thin webhook endpoints that deserialise incoming messages and route them to the appropriate SessionGrain:

Custom chat widgets for your website
Industry-specific messaging systems
IoT device interfaces

Tool Providers

Extend the agent’s built-in tool set with new capabilities:

Database query tools
API integration tools
File processing and transformation tools
Browser automation extensions

SDK Components

komand-sdk/
├── src/
│   ├── Komand.Sdk.Contracts/     # IKomandSkill, SkillDefinition, schemas
│   ├── Komand.Sdk.Runtime/       # Execution runtime, SkillContext, SkillResult
│   ├── Komand.Sdk.Testing/       # SkillTestContext, mocks, assertion helpers
│   └── Komand.Sdk.Cli/           # CLI tools for pack/publish workflow
├── templates/                     # dotnet new project templates
├── examples/                      # Example skill implementations
└── docs/                          # SDK API documentation

Key Abstractions

Type	Purpose
`IKomandSkill`	Interface every skill implements
`SkillDefinition`	Metadata: ID, name, schemas, permissions, publisher
`SkillContext`	Runtime context passed to `ExecuteAsync` — input, credentials, logging
`SkillResult`	Return type with `Success(data)` and `Failure(error)` factory methods
`SkillTestContext`	Test double for `SkillContext` used in unit tests

Quick Example

using Komand.Sdk.Contracts;
using Komand.Sdk.Runtime;

public class WeatherSkill : IKomandSkill
{
    public SkillDefinition Definition => new()
    {
        SkillId = "weather-lookup",
        Name = "Weather Lookup",
        Description = "Get current weather for a location",
        Version = "1.0.0",
        PublisherId = "komand-official",
        InputSchema = JsonSchema.FromType<WeatherInput>(),
        OutputSchema = JsonSchema.FromType<WeatherOutput>(),
        RequiredPermissions = ["network:outbound"]
    };

    public async Task<SkillResult> ExecuteAsync(
        SkillContext context,
        CancellationToken ct)
    {
        var input = context.GetInput<WeatherInput>();
        var weather = await FetchWeatherAsync(input.Location, ct);

        return SkillResult.Success(new WeatherOutput
        {
            Temperature = weather.Temp,
            Conditions = weather.Description,
            Location = input.Location
        });
    }
}

public record WeatherInput(string Location);
public record WeatherOutput(double Temperature, string Conditions, string Location);

How Skills Execute

When an agent invokes a skill, the platform:

Validates permissions — the agent’s granted permissions are checked against the skill’s RequiredPermissions
Creates a ToolGrain — a dedicated Orleans grain manages the execution lifecycle
Calls ExecuteAsync — the skill receives a SkillContext with validated input and scoped credentials
Returns the result — SkillResult is sanitised and fed back to the agent’s conversation

Next Steps

Skill Development — step-by-step guide to building your first skill
Marketplace — publishing, review process, and revenue sharing
Skills Guide — how skills work from the platform perspective
Grain Model — ToolGrain and SkillRegistryGrain details