NeboAI
NeboAI
Kom i gang

Byg apps til Nebo

Giv din AI nye superkræfter. Værktøjer, kanaler, gateways, UI-paneler — alt, hvad du kan forestille dig, kompileret til en native binær.

Oversigt

Hvad Nebo er

Nebo er en personlig AI-assistent på computeren — en AI-medarbejder, der altid kører og styrer dit digitale liv. Tænk på Nebo, som du tænker på en smartphone: en stærk platform, der bliver banebrydende gennem sine apps.

I sig selv er Nebo en dygtig AI-medarbejder med hukommelse, planlægning, webbrowsing, filhåndtering og shelladgang. Men det, der for alvor åbner op, er apps. Ligesom en smartphones styrke kommer fra dens app-økosystem, kommer Nebos styrke fra de apps, der udvider, hvad den kan.

Hvad apps er

Nebo-apps er selvstændige, præcompilerede enheder med utrolig funktionalitet. Hver app giver Nebo en ny superkraft — kalenderstyring, sortering af e-mails, projektopfølgning, hjemmeautomatisering, økonomisk analyse — alt, hvad en udvikler kan forestille sig.

Apps giver utrolig styrke på en meget sikker måde. Hver app kører i en sandkasse med tilladelser, der som standard er afvist. Den kan kun få adgang til det, dens manifest erklærer, og som brugeren godkender.

Grænsefladen er 100 % samtalebaseret. Brugerne interagerer ikke med apps gennem separate skærme eller dashboards. De taler med Nebo, og Nebo bruger appens værktøjer til at få tingene gjort. "Hvad står der i min kalender i morgen?" — Nebo kalder kalenderappen. "Opret et møde med Sarah kl. 3" — Nebo kalder kalenderappen. Brugeren forlader aldrig samtalen.

Apps kan valgfrit tilbyde en indstillingsgrænseflade — et konfigurationspanel, der åbner i Nebos indbyggede browservindue. Her indtaster brugerne API-nøgler, slår funktioner til og fra og konfigurerer appen. Indstillingsgrænsefladen styres af arrayet settings i manifestet (Nebo gengiver formularen automatisk), eller appen kan levere sin egen fuldt tilpassede grænseflade via funktionen ui.

Apps erstatter og udvider Nebos indbyggede funktioner. Nebo leveres med grundlæggende platformsværktøjer (lokal kalenderadgang, skærmbilleder osv.). Når du installerer en kalenderapp, erstatter den det indbyggede kalenderværktøj og bliver et supersæt — lokal + sky + samling + tjek af ledighed.

Politik om kun kompileret kode

Nebo håndhæver en streng politik om kun kompilerede binære filer. Alle apps skal være native kompilerede programmer.

StatusSprog
UnderstøttetGo (anbefalet), Rust, C/C++, Zig
AfvistPython, Node.js, Ruby, Java, .NET, shellscripts

Begrundelse:

  • Forhindrer at AI ændrer sig selv — En AI-medarbejder med shelladgang kunne ændre et fortolket scripts adfærd under kørsel. Kompilerede binære filer kan ikke ændres efter signering.
  • Signaturens integritet — Ed25519-signaturer dækker de rå binære bytes. En signeret binær kan ikke ændres uden at gøre signaturen ugyldig.
  • Håndhævelse af sandkassen — Validering af binært format (magiske bytes for ELF/Mach-O/PE) er en hurtig og pålidelig kontrol.

Hurtig start

Installér SDK'et

De officielle SDK'er klarer al opsætning af gRPC-serveren, håndtering af signaler og protokolbroer. Du skal bare implementere handler-interfaces.

Go (anbefalet):

go get github.com/neboloop/nebo-sdk-go

Rust (kommer snart):

# Coming soon
[dependencies]
nebo-sdk = "0.1"

C/C++ (kommer snart):

# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/

Appens mappestruktur

Apps ligger i undermappen apps/ i din Nebo-datamappe:

~/Library/Application Support/Nebo/apps/   # macOS
~/.config/nebo/apps/                        # Linux
%AppData%\Nebo\apps\                        # Windows

apps/
  com.example.myapp/
    manifest.json       # Required: app metadata
    binary              # Required: executable (or named "app")
    signatures.json     # Required for NeboAI distribution, optional in dev
    TOOL.md             # Required: tool instructions for the agent
    data/               # Auto-created: app's sandboxed storage
    logs/               # Auto-created: stdout.log, stderr.log
    ui/                 # Optional: static UI assets (HTML/CSS/JS)

Tjekliste for en minimal app

  1. Opret manifest.json med id, name, version, provides
  2. Skriv TOOL.md, der beskriver, hvordan AI-medarbejderen skal bruge dit værktøj
  3. Installér SDK'et (go get github.com/neboloop/nebo-sdk-go)
  4. Implementér handler-interfacet for din funktion (ToolHandler, ChannelHandler osv.)
  5. Registrér handleren, og kald app.Run()
  6. Byg en native binær (go build -o binary .)
  7. Læg binær + manifest.json + TOOL.md i mappen apps/<your-app-id>/
  8. Nebo finder og starter den automatisk

Konfiguration

manifest.json

Alle apps kræver en manifest.json:

{
    "id": "com.example.myapp",
    "name": "My App",
    "version": "1.0.0",
    "description": "What this app does",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:my_tool"],
    "permissions": ["network:outbound"],
    "settings": [
        {
            "key": "api_key",
            "title": "API Key",
            "type": "password",
            "required": true,
            "description": "Your API key for the service",
            "secret": true
        }
    ]
}

Påkrævede felter:

FeltBeskrivelse
idIdentifikator med omvendt domæne (f.eks. com.mycompany.myapp)
nameNavn, der kan læses af mennesker
versionSemver-streng
providesMindst én funktion (se nedenfor)

Valgfrie felter:

FeltStandardBeskrivelse
runtime"local""local" eller "remote"
protocol"grpc"Kun "grpc" understøttes
permissions[]Hvad appen skal have adgang til
description""Vises i grænsefladen
settings[]Indstillinger, der kan konfigureres (gengives i indstillingsgrænsefladen)
oauth[]Krav til OAuth-udbyder (se afsnittet om OAuth nedenfor)

Funktioner

Erklær, hvad din app leverer:

FunktiongRPC-tjenesteBeskrivelse
gatewayGatewayServiceRouting af LLM-modeller
tool:<name>ToolServiceEt navngivet værktøj til AI-medarbejderen
channel:<name>ChannelServiceEn beskedkanal
commCommServiceKommunikation mellem AI-medarbejdere
uiUIServiceTilpasset grænseflade med HTTP-proxy
scheduleScheduleServiceTilpasset planlægning
visionToolServiceBilledbehandling
browserToolServiceBrowserautomatisering

En app kan levere flere funktioner. En app kan for eksempel levere både et værktøj og et UI-panel.

Tilladelser

Tilladelser styrer, hvad appen kan få adgang til. Afvist som standard — hvis det ikke er erklæret, kan appen ikke bruge det.

PræfiksEksemplerBeskrivelse
network:network:outbound, network:*Netværksadgang
filesystem:filesystem:read, filesystem:writeAdgang til filsystemet
memory:memory:read, memory:writeAdgang til AI-medarbejderens hukommelse
session:session:readSamtalesessioner
tool:tool:shell, tool:fileBrug andre værktøjer
shell:shell:execKørsel af shellkommandoer
channel:channel:send, channel:*Kanaloperationer
comm:comm:send, comm:*Kommunikation mellem AI-medarbejdere
model:model:chatAdgang til AI-modeller
user:user:tokenModtag brugerens JWT i anmodninger
schedule:schedule:createStyring af cron-job
database:database:queryDatabaseadgang
storage:storage:read, storage:writeVedvarende lagring
context:context:readAdgang til AI-medarbejderens kontekst
subagent:subagent:spawnOperationer med underagenter
lane:lane:enqueueLane-operationer
notification:notification:sendPush-notifikationer
embedding:embedding:searchAdgang til vektor-embeddings
skill:skill:invokeKald af færdigheder
advisor:advisor:consultAdgang til rådgiversystemet
mcp:mcp:connectAdgang til MCP-servere
voice:voice:recordAdgang til stemme/lyd
browser:browser:navigateBrowserautomatisering
oauth:oauth:google, oauth:*Adgang til OAuth-tokens
settings:settings:readAdgang til indstillinger
capability:capability:registerRegistrering af funktioner

Jokertegn i tilladelser understøttes: network:* matcher ethvert tjek af en network:-tilladelse.

Indstillinger

Indstillinger vises i Nebos grænseflade i appens indstillingspanel. Nebo gemmer dem i databasen og sender dem til din app via RPC'en Configure, når de ændres.

Dit indstillingsskema indgår i appens oversigt i NeboAI's appbutik. Apps med påkrævede indstillinger, der ikke er konfigureret, viser mærket "Kræver opsætning" i grænsefladen.

TypeBeskrivelse
textTekstfelt med én linje
passwordMaskeret tekstfelt
toggleBoolesk tænd/sluk-kontakt
selectRulleliste med foruddefinerede valg
numberTalfelt
urlURL-felt med validering
{
    "key": "region",
    "title": "Region",
    "type": "select",
    "required": true,
    "default": "us-east-1",
    "options": [
        {"label": "US East", "value": "us-east-1"},
        {"label": "EU West", "value": "eu-west-1"}
    ]
}

OAuth-krav

Apps kan erklære krav til OAuth-udbydere. Nebos OAuth-broker klarer hele forløbet — apps modtager tokens automatisk via RPC'en Configure.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
FeltBeskrivelse
providerOAuth-udbyder: "google", "microsoft", "github"
scopesArray af OAuth-scopes, som appen har brug for

Når brugeren installerer appen, beder Nebo vedkommende om at godkende de påkrævede OAuth-scopes. Appen modtager fornyede tokens via RPC'en Configure uden selv at håndtere OAuth-forløbet.

Miljøvariabler

Din apps proces modtager et renset miljø. Alle hemmeligheder er fjernet. Du får:

VariabelVærdi
NEBO_APP_DIRAppens installationsmappe
NEBO_APP_SOCKSti til den Unix-socket, der skal oprettes
NEBO_APP_IDApp-ID fra manifestet
NEBO_APP_NAMEAppnavn fra manifestet
NEBO_APP_VERSIONAppversion fra manifestet
NEBO_APP_DATASti til appens mappe data/
PATHSystemets PATH (videregives)
HOMEBrugerens hjemmemappe (videregives)
TMPDIRMidlertidig mappe (videregives)

Vigtigt: Din binær skal oprette en gRPC-server, der lytter på Unix-socketten ved NEBO_APP_SOCK. Nebo venter op til 10 sekunder på, at socketten dukker op.

Appens opstartsforløb

  1. Nebo læser manifest.json og validerer den
  2. Finder programmet binary eller app i appens mappe
  3. Tjekker for markøren .quarantined (nægter at starte apps i karantæne)
  4. Tjek for tilbagekaldelse (kun apps distribueret af NeboAI)
  5. Verificering af signatur (kun apps distribueret af NeboAI, springes over under udvikling)
  6. Validering af binær (afviser symlinks, scripts, ikke-eksekverbare filer og for store filer)
  7. Rydder en gammel socket fra forrige kørsel op
  8. Opretter mappen data/ til lagring i sandkassen
  9. Opsætter logfiler pr. app (logs/stdout.log, logs/stderr.log)
  10. Starter binæren med et renset miljø og isolering af procesgruppe
  11. Venter på, at Unix-socketten dukker op (eksponentiel backoff, højst 10 sekunder)
  12. Forbinder via gRPC over Unix-socketten
  13. Opretter funktionsspecifikke gRPC-klienter ud fra provides
  14. Kører sundhedstjek
  15. Registrerer funktioner hos AI-medarbejderen (værktøjer, gateway, comm osv.)

Værktøjsapps

Erklær "provides": ["tool:my_tool_name"] i dit manifest.

STRAP-mønsteret

Alle Nebos værktøjsapps skal bruge STRAP (Single Tool Resource Action Pattern) til deres skema og routing af kørsel. Det er det samme mønster, Nebo bruger internt til at samle mere end 35 enkeltværktøjer i 4 domæneværktøjer — det reducerer LLM-kontekstens overhead med ca. 80 %.

Grundidé: I stedet for at registrere flere værktøjer (get_events, check_availability, suggest_slots) registrerer du ÉT værktøj med felterne action (og eventuelt resource), der sender videre til den rette handler.

Eksempel med én ressource (kalender):

calendar(action: "get_events", start: "2025-01-15T09:00:00Z", end: "2025-01-16T00:00:00Z")
calendar(action: "next_event")
calendar(action: "check_availability", start: "...", end: "...")
calendar(action: "suggest_slots", duration_minutes: 30, preferred_time: "morning")

Eksempel med flere ressourcer (projektstyring):

project(resource: "task", action: "create", title: "Ship v2", assignee: "alice")
project(resource: "task", action: "list", status: "open")
project(resource: "milestone", action: "create", name: "Beta", deadline: "2025-03-01")
project(resource: "milestone", action: "list")

Regler for skemaet:

  1. Medtag altid feltet action som en påkrævet streng-enum
  2. Tilføj feltet resource (påkrævet streng-enum) kun, hvis dit værktøj håndterer flere forskellige ressourcetyper
  3. Alle andre felter er parametre, der hører til den enkelte handling
  4. Beskrivelsen af enum'en action skal angive alle tilgængelige handlinger

Derfor betyder STRAP noget:

  • LLM'er lærer routingmønsteret for action én gang og generaliserer på tværs af alle operationer
  • Værktøjsdefinitioner bruger ca. 6 % af konteksten — STRAP skærer det ned med 80 %
  • Nye operationer er bare tilføjelser til enum'en, ikke nye værktøjsregistreringer
  • Fungerer ens på tværs af hostede og lokale modeller

Go-eksempel — Lommeregnerværktøj

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    nebo "github.com/neboloop/nebo-sdk-go"
)

type Calculator struct{}

func (c *Calculator) Name() string        { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }

func (c *Calculator) Schema() json.RawMessage {
    return nebo.NewSchema("add", "subtract", "multiply", "divide").
        Number("a", "First operand", true).
        Number("b", "Second operand", true).
        Build()
}

func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
    var in struct {
        Action string  `json:"action"`
        A      float64 `json:"a"`
        B      float64 `json:"b"`
    }
    if err := json.Unmarshal(input, &in); err != nil {
        return "", fmt.Errorf("invalid input: %w", err)
    }

    var result float64
    switch in.Action {
    case "add":
        result = in.A + in.B
    case "subtract":
        result = in.A - in.B
    case "multiply":
        result = in.A * in.B
    case "divide":
        if in.B == 0 {
            return "", fmt.Errorf("division by zero")
        }
        result = in.A / in.B
    default:
        return "", fmt.Errorf("unknown action: %s", in.Action)
    }

    return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterTool(&Calculator{})
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.calculator",
    "name": "Calculator",
    "version": "1.0.0",
    "description": "Arithmetic calculator tool for the agent",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["tool:calculator"],
    "permissions": []
}

Byg og installér:

go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/

Rust-eksempel

use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;

struct Calculator;

#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }

#[async_trait]
impl ToolHandler for Calculator {
    fn name(&self) -> &str { "calculator" }
    fn description(&self) -> &str { "Performs arithmetic calculations." }
    fn schema(&self) -> Value {
        SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
            .number("a", "First operand", true)
            .number("b", "Second operand", true)
            .build()
    }
    async fn execute(&self, input: Value) -> Result<String, NeboError> {
        let i: Input = serde_json::from_value(input)
            .map_err(|e| NeboError::Execution(e.to_string()))?;
        let r = match i.action.as_str() {
            "add" => i.a + i.b,
            "subtract" => i.a - i.b,
            "multiply" => i.a * i.b,
            "divide" => {
                if i.b == 0.0 {
                    return Err(NeboError::Execution("division by zero".into()));
                }
                i.a / i.b
            }
            other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
        };
        Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    NeboApp::new()?.register_tool(Calculator).run().await?;
    Ok(())
}

C-eksempel

#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int calculator_execute(const char *input_json, char **output, int *is_error) {
    /* Parse JSON, compute result, set *output */
    *output = strdup("2 add 3 = 5");
    *is_error = 0;
    return 0;
}

int main(void) {
    const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
    nebo_schema_builder_t *sb = nebo_schema_new(actions);
    nebo_schema_number(sb, "a", "First operand", 1);
    nebo_schema_number(sb, "b", "Second operand", 1);
    char *schema = nebo_schema_build(sb);
    nebo_schema_free(sb);

    nebo_tool_handler_t calculator = {
        .name = "calculator",
        .description = "Performs arithmetic calculations.",
        .schema = schema,
        .execute = calculator_execute,
    };

    nebo_app_t *app = nebo_app_new();
    nebo_app_register_tool(app, &calculator);
    int ret = nebo_app_run(app);
    free(schema);
    return ret;
}

Kanalapps

Erklær "provides": ["channel:my_channel"] og "permissions": ["channel:send"].

Kanalapps forbinder eksterne beskedplatforme (Telegram, Discord, Slack osv.) med Nebos AI-medarbejder. Når en bruger sender en besked på den eksterne platform, streamer din app den til Nebo via Receive. Når AI-medarbejderen vil svare, kalder Nebo din apps Send.

Sådan fungerer det

  1. Nebo kalder ID() for at få din kanals unikke identifikator
  2. Nebo kalder Connect() med konfiguration fra din apps indstillinger
  3. Nebo åbner en Receive()-stream — din app sender indgående beskeder, hver gang en bruger skriver til botten
  4. Indgående beskeder sendes til AI-medarbejderens primære samtalelane
  5. Når AI-medarbejderen vil sende en besked, kalder Nebo Send() med v1-beskedkonvolutten
  6. Ved nedlukning kalder Nebo Disconnect()

v1-beskedkonvolut

Alle kanalbeskeder — indgående og udgående — bruger den fælles beskedkonvolut:

{
  "message_id": "01953f8a-...",
  "channel_id": "telegram:12345",
  "sender": { "name": "Alex", "role": "COO", "bot_id": "uuid" },
  "text": "Q3 numbers look good...",
  "attachments": [{ "type": "image", "url": "https://...", "filename": "chart.png", "size": 45000 }],
  "reply_to": "01953f89-...",
  "actions": [{ "label": "Approve", "callback_id": "approve_q3" }],
  "platform_data": null,
  "timestamp": "2026-02-12T15:10:00Z"
}
FeltTypeBeskrivelse
message_idUUID v7Tidsordnet unikt ID
channel_id{type}:{platform_id}Kanalidentifikator, der kan routes
senderobjectBotidentitet — navn, rolle, botId
textstringBeskedens indhold
attachmentsarrayFiler, billeder, lyd
reply_toUUID v7Overordnet besked-ID til tråde
actionsarrayInteraktive knapper/tastaturer
platform_databytesUigennemsigtig videregivelse til platformsspecifikke funktioner
timestampISO 8601Udgiveren angiver dette

Design i to lag: De fælles felter (text, attachments, reply_to, actions) dækker 90 % af de beskeder, medarbejdere selv starter. Platformsspecifikke funktioner går i platform_data — dit plugin oversætter dem til og fra platformens eget format.

Samtalestreams

Kanalbeskeder sendes over samtalestreams pr. kanal af hensyn til isolering:

neboai/bot/{botID}/channels/{channelType}/inbound    # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound   # messages from agent → channel

Go-eksempel — Telegram-kanal

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "time"

    "github.com/google/uuid"
    tgbot "github.com/go-telegram/bot"
    nebo "github.com/neboloop/nebo-sdk-go"
)

type Telegram struct {
    bot      *tgbot.Bot
    messages chan nebo.ChannelEnvelope
    cancel   context.CancelFunc
}

func (t *Telegram) ID() string { return "telegram" }

func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
    token := config["bot_token"]
    if token == "" {
        return fmt.Errorf("bot_token is required")
    }

    botCtx, cancel := context.WithCancel(context.Background())
    t.cancel = cancel

    bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
        func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
            if update.Message == nil {
                return
            }
            env := nebo.ChannelEnvelope{
                MessageID: uuid.Must(uuid.NewV7()).String(),
                ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
                Text:      update.Message.Text,
                Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
            }
            t.messages <- env
        },
    ))
    if err != nil {
        return err
    }

    t.bot = bot
    go bot.Start(botCtx)
    return nil
}

func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
    if t.bot == nil {
        return "", fmt.Errorf("not connected")
    }
    chatID := env.ChannelID[len("telegram:"):]
    params := &tgbot.SendMessageParams{
        ChatID: chatID,
        Text:   env.Text,
    }
    msg, err := t.bot.SendMessage(ctx, params)
    if err != nil {
        return "", err
    }
    return fmt.Sprintf("%d", msg.MessageID), nil
}

func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
    return t.messages, nil
}

func (t *Telegram) Disconnect(_ context.Context) error {
    if t.cancel != nil {
        t.cancel()
    }
    return nil
}

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterChannel(&Telegram{
        messages: make(chan nebo.ChannelEnvelope, 100),
    })
    log.Fatal(app.Run())
}

manifest.json:

{
    "id": "com.example.telegram",
    "name": "Telegram",
    "version": "1.0.0",
    "description": "Telegram messaging channel for Nebo",
    "runtime": "local",
    "protocol": "grpc",
    "provides": ["channel:telegram"],
    "permissions": ["channel:send", "network:outbound"],
    "settings": [
        {
            "key": "bot_token",
            "title": "Bot Token",
            "type": "password",
            "required": true,
            "description": "Telegram bot token from @BotFather",
            "secret": true
        }
    ]
}

Flere funktioner

Comm-app

Erklær "provides": ["comm"] og "permissions": ["comm:*"]. Comm-apps gør kommunikation mellem AI-medarbejdere mulig.

FeltBeskrivelse
fromAfsenderens medarbejder-ID
toModtagerens medarbejder-ID
topicBeskedens emne/kanal
type"message", "mention", "proposal", "command", "info", "task"
contentBeskedens indhold

Vigtig adfærd:

  • Register annoncerer denne AI-medarbejder på netværket med dens funktioner
  • Subscribe/Unsubscribe styrer abonnementer på emner
  • Receive streamer indgående beskeder (server-streaming, ligesom kanaler)
  • Kun én comm-app kan være aktiv ad gangen

Gateway-app

En gateway-app sender LLM-anmodninger videre til modeller. Erklær "provides": ["gateway"] og "permissions": ["network:outbound", "user:token"].

GatewayRequest indeholder beskeder, værktøjer, systemprompt, maks. tokens, temperatur og en UserContext (JWT-token, hvis tilladelsen user:token er givet).

GatewayEvent-typer:

TypeIndholdBeskrivelse
"text"TekststykkeStreamet teksttoken
"tool_call"JSONModellen vil kalde et værktøj
"thinking"TekststykkeUdvidet tænkning/ræsonnement
"error"FejlbeskedNoget gik galt
"done"TomStreamen er færdig

UI-app

En UI-app leverer en tilpasset konfigurationsgrænseflade, der åbner i Nebos indbyggede browservindue. Erklær "provides": ["ui"]. I modsætning til den automatiske indstillingsformular (som Nebo gengiver ud fra dit manifests settings) serverer en UI-app sin egen fulde HTML/CSS/JS-frontend.

Din app leveres med en mappe ui/ med statiske webfiler (HTML, CSS, JS — typisk en SPA med index.html). Nebo serverer filerne direkte og sender API-kald videre til din app via gRPC.

StiMekanismeFormål
GET /api/v1/apps/{id}/ui/*Statisk filserverServerer filer fra din mappe ui/ (SPA-fallback til index.html)
ANY /api/v1/apps/{id}/api/*gRPC-proxySender HTTP-anmodninger videre til din apps UIService.HandleRequest()

SDK'et pakker en standard net/http.ServeMux ind, så du skriver almindelige Go HTTP-handlers — SDK'et klarer gRPC-broen automatisk.

Go-eksempel — Dashboard-grænseflade:

package main

import (
    "encoding/json"
    "log"
    "net/http"

    nebo "github.com/neboloop/nebo-sdk-go"
)

type Dashboard struct {
    mux *http.ServeMux
}

func NewDashboard() *Dashboard {
    d := &Dashboard{mux: http.NewServeMux()}

    d.mux.HandleFunc("GET /status", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
    })

    d.mux.HandleFunc("POST /action", func(w http.ResponseWriter, r *http.Request) {
        var req map[string]string
        json.NewDecoder(r.Body).Decode(&req)
        json.NewEncoder(w).Encode(map[string]string{"result": "done"})
    })

    return d
}

func (d *Dashboard) Handler() *http.ServeMux { return d.mux }

func main() {
    app, err := nebo.New()
    if err != nil {
        log.Fatal(err)
    }
    app.RegisterUI(NewDashboard())
    log.Fatal(app.Run())
}

Din ui/index.html ville lave fetch-kald til /api/v1/apps/com.example.dashboard/api/status, som sendes videre til din mux-handler.

Planlægningsapp

En planlægningsapp erstatter Nebos indbyggede cron-planlægger. Erklær "provides": ["schedule"] og "permissions": ["schedule:create"].

Når din planlægningsapp starter, sender Nebo al planlægning gennem din app i stedet for standard-cron-motoren. Hvis din app går ned, falder Nebo automatisk tilbage til den indbyggede motor.

  • Din app ejer planlægningstilstanden — Nebo gemmer ikke tidsplaner i sin egen database, når en planlægningsapp er aktiv
  • Standard-CRUD: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers er en server-streaming RPC — din app sender en udløserbesked, hver gang en tidsplan udløses
  • Kun én planlægningsapp kan være aktiv ad gangen

Apps med flere funktioner

En app kan levere flere funktioner. For eksempel en dashboard-app med både et værktøj og en grænseflade:

{
    "id": "com.example.dashboard",
    "name": "Dashboard",
    "version": "1.0.0",
    "provides": ["tool:dashboard_query", "ui"],
    "permissions": ["network:outbound"]
}
app, _ := nebo.New()
app.RegisterTool(&dashboardTool{})
app.RegisterUI(&dashboardUI{})
log.Fatal(app.Run())

Pakning

.napp-format

Til distribution gennem NeboAI pakker du din app som en .napp-fil (et tar.gz-arkiv):

cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md

Påkrævede filer:

FilMaks. størrelseBeskrivelse
manifest.json1 MBAppens metadata
binary eller app500 MBProgram
signatures.json1 MBEd25519-signaturer
TOOL.md1 MBVærktøjsinstruktioner til AI-medarbejderen

Sikkerhedsregler under udpakning:

  • Ingen stigennemløb (../ afvises)
  • Ingen symlinks (afvises)
  • Ingen absolutte stier (afvises)
  • Kun godkendte filnavne accepteres

Signaturer

NeboAI signerer apps med Ed25519. Formatet for signatures.json:

{
    "key_id": "a1b2c3d4",
    "algorithm": "ed25519",
    "manifest_signature": "<base64 signature of raw manifest.json bytes>",
    "binary_sha256": "<hex SHA256 of binary>",
    "binary_signature": "<base64 signature of raw binary bytes>"
}

I udviklingstilstand (ingen NeboAI-URL konfigureret) springes verificering af signaturer helt over. Du behøver ikke signatures.json til lokal udvikling.

Udgivelse

Når din app virker lokalt, kan du udgive den gennem NeboAI, så den distribueres til alle Nebo-brugere.

Opsætning af udviklerkonto

  1. Registrér en NeboAI-konto på POST /api/v1/owners/register
  2. Log ind for at få et JWT-token: POST /api/v1/owners/login
  3. Opret en udviklerkonto: POST /api/v1/developer/accounts

Forløb for indsendelse

draft → pending_review → [approved] → published
                       → [rejected] → draft (fix and resubmit)

Trin 1: Opret appen

curl -X POST https://neboai.com/api/v1/developer/apps \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My App",
    "version": "1.0.0",
    "description": "What it does",
    "category": "productivity",
    "visibility": "public"
  }'

Trin 2: Upload binære filer til platformene

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/binaries \
  -H "Authorization: Bearer $TOKEN" \
  -F "binary=@myapp-darwin-arm64" \
  -F "platform=darwin-arm64"

Upload én binær pr. platform: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Trin 3: Indsend til gennemgang

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
  -H "Authorization: Bearer $TOKEN"

Sådan foregår gennemgangen

  1. Automatisk scanning — binære filer scannes via VirusTotal
  2. Gennemgang af administrator — NeboAI-teamet gennemgår metadata, manifest og scanningsresultater
  3. Ved godkendelse — NeboAI signerer appen med Ed25519 og udgiver den
  4. Ved afvisning — du får en begrundelse og kan rette og indsende igen

Mål for gennemgangstid: <24 timer.

Udgiv opdateringer

  1. Opdater appens version: PUT /api/v1/developer/apps/{id} med den nye version
  2. Upload nye binære filer til hver platform
  3. Indsend til gennemgang igen

Hver opdatering gennemgår den samme proces. Tidligere versioner forbliver tilgængelige, indtil den nye version er godkendt.

Metadata til butikken

FeltBeskrivelse
categoryf.eks. productivity, communication, developer-tools
iconURL til appikon
visibilitypublic eller private
descriptionKan være længere/mere udførlig end beskrivelsen i manifestet

Udviklingsforløb

Lokal udvikling

Ingen pakning nødvendig til lokal udvikling:

  1. Opret din app-mappe:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Skriv din manifest.json og din kode
  3. Byg din binærfil:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo opdager automatisk den nye mappe (eller genstart Nebo)
  5. Byg binæren igen efter ændringer i koden — filovervågningen genstarter appen

Se logs

Appens stdout/stderr opsamles i logfiler pr. app:

tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stdout.log
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stderr.log

Vedvarende data

Brug mappen data/ (også tilgængelig som miljøvariablen NEBO_APP_DATA) til alle filer, din app skal gemme. Mappen overlever appopdateringer og karantæne.

Tips til fejlfinding

  • Hvis din app ikke starter, så tjek logs/stderr.log for fejl
  • Sørg for, at binæren er eksekverbar (chmod +x binary)
  • Sørg for, at du lytter på Unix-socketstien fra NEBO_APP_SOCK
  • Socketten skal være klar inden for 10 sekunder efter start
  • Brug NEBO_APP_DATA til lagring, ikke hardkodede stier
  • Skriv til stderr for fejlfindingslogs (opsamles i logs/stderr.log)

Verificering

# List installed apps
nebo apps list

# Check running apps via the web UI Settings > Apps
# Or check the apps directory for running sockets
ls ~/Library/Application\ Support/Nebo/apps/*/app.sock

Afinstallation

nebo apps uninstall com.example.myapp

Færdigheder

Hvad færdigheder er

Færdigheder er sæt af instruktioner, der former, hvordan Nebo opfører sig i en samtale. Når en færdighed er aktiv, indsættes dens indhold direkte i systemprompten — og styrer AI-medarbejderens tone, metode, fagekspertise og brug af værktøjer i den session.

Færdigheder er ikke kode. De er markdown-dokumenter med YAML-metadata. Ingen kompilering, ingen binær, ingen gRPC. En færdighed er en SKILL.md-fil i en mappe. Det er det hele.

Færdigheder er kontekstuelle og midlertidige. De aktiveres, når de er relevante (via udløsermatch eller manuel indlæsning), bliver ved i nogle få ture og udløber, når der ikke længere er brug for dem. Det holder AI-medarbejderens kontekst slank — kun den vejledning, der betyder noget lige nu, er i prompten.

Færdigheder supplerer apps. Apps giver eksekverbare evner (værktøjer, kanaler, gateways). Færdigheder giver vejledning i orkestrering — hvordan værktøjerne bruges effektivt. En kalenderapp giver Nebo mulighed for at læse og skrive begivenheder. En "mødeforberedelse"-færdighed fortæller Nebo, hvordan den forbereder møder med kalenderappen, e-mail og websøgning sammen.

Færdigheder vs. apps

FærdighederApps
FormatMarkdown (SKILL.md)Kompileret binær (.napp)
KørselIndsættes i systempromptenProces i sandkasse over gRPC
LevererVejledning i adfærd, metodeVærktøjer, kanaler, UI-paneler
LevetidGælder for sessionen, udløber efter TTLKører altid
OprettelseSkriv en markdown-filSkriv, kompilér, signér, pak
SikkerhedIngen tilladelser nødvendigeSandkasse med afvisning som standard

Hurtig start

Opret en mappe i din Nebo-mappe til færdigheder med en SKILL.md-fil:

~/Library/Application Support/Nebo/skills/   # macOS
~/.config/nebo/skills/                        # Linux
%AppData%\Nebo\skills\                        # Windows
mkdir -p ~/.config/nebo/skills/my-skill

Skriv en SKILL.md:

---
name: my-skill
description: One-line description of what this skill does
version: "1.0.0"
triggers:
  - keyword that activates this skill
  - another trigger phrase
---

# My Skill

Instructions for Nebo when this skill is active.

Tell the agent what to do, how to approach problems,
what tools to use, and what tone to take.

Nebo overvåger mappen med færdigheder med fsnotify. Din færdighed er tilgængelig med det samme — ingen genstart nødvendig. Sig noget, der matcher en udløser, så aktiveres den automatisk.

Eller bed Nebo direkte: "Lav en færdighed til at skrive blogindlæg" — så skriver Nebo SKILL.md-filen for dig.

SKILL.md-format

Hver færdighed er en enkelt SKILL.md-fil med to dele: YAML-frontmatter mellem ----markører og en markdown-brødtekst (de egentlige instruktioner, der indsættes i systemprompten).

FeltPåkrævetStandardBeskrivelse
nameJa—Unik identifikator (bliver til slug)
descriptionJa—Beskrivelse på én linje, der vises i kataloget over færdigheder
versionNej"1.0.0"Semver til at følge opdateringer
authorNej—Færdighedens forfatter
priorityNej0Højere = matches først (100+ for kritiske tilsidesættelser)
max_turnsNej4Antal inaktive ture før automatisk udløb
triggersNej[]Fraser, der automatisk aktiverer denne færdighed (match på delstreng, uden forskel på store og små bogstaver)
toolsNej[]Værktøjer, som færdigheden forventer at bruge (til orientering)
dependenciesNej[]Andre færdigheder, der skal være installeret
tagsNej[]Til kategorisering og opdagelse
platformNej[]Understøttede platforme: macos, linux, windows (tom = alle)

Sådan aktiveres færdigheder

Færdigheder følger en aktiveringsmodel i to faser: hint og derefter kald.

Fase 1: Udløsermatch — Hver gang en bruger sender en besked, scanner Nebo alle registrerede færdigheder for udløsermatch. Matchende færdigheder vises som hints i systemprompten. AI-medarbejderen ser hintet og beslutter, om færdigheden skal kaldes.

Fase 2: Kald — AI-medarbejderen kalder en færdighed ved at kalde:

skill(name: "code-review")

Det returnerer hele SKILL.md-skabelonen som værktøjsresultat, registrerer kaldet og indsætter skabelonen i systemprompten igen i de følgende ture.

TTL og udløb:

  • Automatisk matchede færdigheder: 4 inaktive ture (kan konfigureres via max_turns)
  • Manuelt indlæste færdigheder: 6 inaktive ture
  • Et nyt kald nulstiller timeren
  • Fast loft: højst 4 aktive færdigheder pr. session
  • Tokenbudget: samlet indhold af aktive færdigheder begrænset til 16.000 tegn

Administration af færdigheder

AI-medarbejderen kan administrere færdigheder via værktøjet skill:

HandlingBeskrivelseEksempel
catalogVis alle tilgængelige færdighederskill(action: "catalog")
loadAktivér for denne sessionskill(name: "code-review", action: "load")
unloadDeaktivér en færdighedskill(name: "code-review", action: "unload")
createOpret en ny færdighed på diskenskill(action: "create", content: "...")
updateOpdatér en eksisterende færdighedskill(name: "my-skill", action: "update", content: "...")
deleteSlet en færdighed fra diskenskill(name: "my-skill", action: "delete")

Skriv gode færdigheder

En god færdighedsskabelon har:

  1. En tydelig overskrift — fortæller AI-medarbejderen, hvilken tilstand den er i
  2. Grundprincipper — de adfærdsregler, der ikke kan forhandles
  3. Metode — trinvis fremgangsmåde for almindelige scenarier
  4. Eksempler — konkrete mønstre fra brugerbesked til svar
  5. Antimønstre — hvad man IKKE skal gøre (modeller lærer godt af negative eksempler)

Tip: Hver færdighed skal gøre én ting godt. Lav ikke en færdighed til "generel programmering" — lav code-review, debugging, api-design som separate færdigheder. AI-medarbejderen kan have flere aktive på samme tid.

Medfølgende færdigheder

Nebo leveres med færdigheder, der dækker almindelige brugsscenarier:

FærdighedPrioritetBeskrivelse
onboarding100Velkomst til nye brugere og indsamling af profil
best-friend50Personlighedsfærdighed — afslappet, loyal, ærlig snak
debugging25Systematisk metode til fejlfinding
api-design15Bedste praksis for design af RESTful API'er
code-review10Struktureret kodegennemgang med alvorlighedsniveauer
database-expert10Databasedesign, forespørgsler, optimering
git-workflow10Git-branches, commits, PR-workflows
security-audit10Sikkerhedsanalyse og registrering af sårbarheder

De fungerer både som nyttige standarder og som referenceimplementeringer, når du laver dine egne færdigheder.

Reference

Proto-filer

Proto-filer ligger i proto/apps/v0/. SDK'erne leveres med forudgenereret kode, så du behøver ikke protoc til almindelig udvikling.

FilTjenesteVigtige RPC'er
v0/common.proto(kun beskeder)HealthCheckRequest/Response, SettingsMap, UserContext, Empty
v0/tool.protoToolServiceName, Description, Schema, Execute, RequiresApproval, Configure
v0/channel.protoChannelServiceID, Connect, Disconnect, Send, Receive (stream), Configure
v0/comm.protoCommServiceName, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure
v0/gateway.protoGatewayServiceHealthCheck, Stream (stream), Poll, Cancel, Configure
v0/ui.protoUIServiceHealthCheck, HandleRequest, Configure
v0/schedule.protoScheduleServiceHealthCheck, Create, Get, List, Update, Delete, Enable, Disable, Trigger, History, Triggers (stream), Configure

Hver tjeneste indeholder RPC'erne HealthCheck og Configure. SDK'et håndterer begge automatisk.

Proto-typer for kanaler

BeskedtypeBeskrivelse
ChannelSendRequestKonvolut til udgående besked med message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponsePlatformens besked-ID til tråde
InboundMessageKonvolut til indgående besked med alle fælles felter + tidsstempel
MessageSenderBotidentitet (name, role, botId) — beriget af brokeren
AttachmentVedhæftet fil/billede/lyd (type, url, filename, size)
MessageActionInteraktiv knap-/tastaturhandling (label, callback_id)

Botidentitet og roller

Nebo-bots har en identitetsmodel med tre akser:

  • creature — Hvad botten er (arketype): "Kvik strateg", "Omhyggelig researcher"
  • role — Hvordan den forholder sig til brugeren (relation): "Ven", "COO", "Mentor"
  • vibe — Dens energi (kommunikationsstil): "Afslappet, men med holdninger", "Varm og opmuntrende"

Når dit kanalplugin modtager en udgående besked, indeholder feltet sender bottens name og role. Brug dem til at formatere visningsnavnet til din platform. Rollen er ikke en jobtitel — den beskriver en relation. "Ven", "Søn" og "Mentor" er gyldige roller side om side med "COO" og "DevLead".