NeboAI
NeboAI
Kom igång

Bygg appar för Nebo

Ge din AI nya superkrafter. Verktyg, kanaler, gateways, UI-paneler — allt du kan tänka dig, kompilerat till en inbyggd binärfil.

Översikt

Vad Nebo är

Nebo är en personlig AI-assistent för datorn — en AI-medarbetare som alltid är igång och sköter ditt digitala liv. Tänk på Nebo som du tänker på en smartphone: en kraftfull plattform som blir omvälvande tack vare sina appar.

På egen hand är Nebo en kapabel AI-medarbetare med minne, schemaläggning, webbsurfning, filhantering och skalåtkomst. Men det verkliga lyftet är appar. Precis som en smartphones kraft kommer från dess app-ekosystem kommer Nebos kraft från apparna som utökar vad den kan göra.

Vad appar är

Nebo-appar är fristående, förkompilerade enheter med otrolig funktionalitet. Varje app ger Nebo en ny superkraft — kalenderhantering, sortering av e-post, projektuppföljning, hemautomation, finansiell analys — allt en utvecklare kan tänka sig.

Appar ger otrolig kraft på ett mycket säkert sätt. Varje app körs i en sandlåda där allt är nekat som standard. Den kommer bara åt det som dess manifest deklarerar och som användaren godkänner.

Gränssnittet är till 100 % konversationsbaserat. Användare interagerar inte med appar via separata skärmar eller instrumentpaneler. De pratar med Nebo, och Nebo använder appens verktyg för att få saker gjorda. ”Vad har jag i kalendern i morgon?” — Nebo anropar kalenderappen. ”Boka ett möte med Sarah kl. 15” — Nebo anropar kalenderappen. Användaren lämnar aldrig konversationen.

Appar kan även erbjuda ett inställningsgränssnitt — en konfigurationspanel som öppnas i Nebos inbyggda webbläsarfönster. Här anger användarna API-nycklar, slår på och av funktioner och konfigurerar appen. Inställningsgränssnittet styrs av arrayen settings i manifestet (Nebo renderar formuläret automatiskt), eller så kan appen erbjuda ett helt eget gränssnitt via funktionen ui.

Appar ersätter och utökar Nebos inbyggda funktioner. Nebo levereras med grundläggande plattformsverktyg (lokal kalenderåtkomst, skärmbilder osv.). När du installerar en kalenderapp ersätter den det inbyggda kalenderverktyget och blir en utökad version — lokalt + moln + sammanställning + kontroll av tillgänglighet.

Policy för endast kompilerad kod

Nebo tillämpar en strikt policy om att endast kompilerade binärfiler tillåts. Alla appar måste vara inbyggda, kompilerade körbara filer.

StatusSpråk
StödsGo (rekommenderas), Rust, C/C++, Zig
AvvisasPython, Node.js, Ruby, Java, .NET, skalskript

Motivering:

  • Förhindrar att AI:n modifierar sig själv — En AI-medarbetare med skalåtkomst skulle kunna ändra ett tolkat skripts beteende under körning. Kompilerade binärfiler går inte att ändra efter signering.
  • Signaturintegritet — Ed25519-signaturer täcker binärfilens råa byte. En signerad binärfil kan inte ändras utan att signaturen blir ogiltig.
  • Sandlådeskydd — Validering av binärformatet (magiska byte för ELF/Mach-O/PE) är en snabb och pålitlig kontroll.

Snabbstart

Installera SDK:n

De officiella SDK:erna sköter all gRPC-serverkonfiguration, signalhantering och protokollbryggning. Du implementerar bara hanterargränssnitt.

Go (rekommenderas):

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 katalogstruktur

Appar ligger i underkatalogen apps/ i din Nebo-datakatalog:

~/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)

Checklista för en minimal app

  1. Skapa manifest.json med id, name, version, provides
  2. Skriv TOOL.md som beskriver hur AI-medarbetaren ska använda ditt verktyg
  3. Installera SDK:n (go get github.com/neboloop/nebo-sdk-go)
  4. Implementera hanterargränssnittet för din funktion (ToolHandler, ChannelHandler osv.)
  5. Registrera hanteraren och anropa app.Run()
  6. Bygg en inbyggd binärfil (go build -o binary .)
  7. Lägg binärfilen + manifest.json + TOOL.md i katalogen apps/<your-app-id>/
  8. Nebo hittar och startar den automatiskt

Konfiguration

manifest.json

Varje app 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
        }
    ]
}

Obligatoriska fält:

FältBeskrivning
idIdentifierare i omvänd domänform (t.ex. com.mycompany.myapp)
nameLäsbart namn
versionSemver-sträng
providesMinst en funktion (se nedan)

Valfria fält:

FältStandardBeskrivning
runtime"local""local" eller "remote"
protocol"grpc"Endast "grpc" stöds
permissions[]Vad appen behöver åtkomst till
description""Visas i gränssnittet
settings[]Konfigurerbara inställningar (renderas i inställningsgränssnittet)
oauth[]Krav på OAuth-leverantör (se avsnittet om OAuth nedan)

Funktioner

Deklarera vad din app tillhandahåller:

FunktiongRPC-tjänstBeskrivning
gatewayGatewayServiceRoutning av LLM-modeller
tool:<name>ToolServiceEtt namngivet verktyg för AI-medarbetaren
channel:<name>ChannelServiceEn meddelandekanal
commCommServiceKommunikation mellan AI-medarbetare
uiUIServiceEget gränssnitt med HTTP-proxy
scheduleScheduleServiceEgen schemaläggning
visionToolServiceBildbehandling
browserToolServiceWebbläsarautomation

En app kan tillhandahålla flera funktioner. En app kan till exempel erbjuda både ett verktyg och en UI-panel.

Behörigheter

Behörigheter styr vad appen kommer åt. Allt är nekat som standard — om något inte är deklarerat kan appen inte använda det.

PrefixExempelBeskrivning
network:network:outbound, network:*Nätverksåtkomst
filesystem:filesystem:read, filesystem:writeÅtkomst till filsystemet
memory:memory:read, memory:writeÅtkomst till AI-medarbetarens minne
session:session:readKonversationssessioner
tool:tool:shell, tool:fileAnvända andra verktyg
shell:shell:execKörning av skalkommandon
channel:channel:send, channel:*Kanaloperationer
comm:comm:send, comm:*Kommunikation mellan AI-medarbetare
model:model:chatÅtkomst till AI-modeller
user:user:tokenTa emot användarens JWT i anrop
schedule:schedule:createHantering av cron-jobb
database:database:queryDatabasåtkomst
storage:storage:read, storage:writeBeständig lagring
context:context:readÅtkomst till AI-medarbetarens kontext
subagent:subagent:spawnOperationer för underagenter
lane:lane:enqueueOperationer för körfält
notification:notification:sendPush-notiser
embedding:embedding:searchÅtkomst till vektorinbäddningar
skill:skill:invokeAnrop av färdigheter
advisor:advisor:consultÅtkomst till rådgivarsystemet
mcp:mcp:connectÅtkomst till MCP-server
voice:voice:recordÅtkomst till röst/ljud
browser:browser:navigateWebbläsarautomation
oauth:oauth:google, oauth:*Åtkomst till OAuth-token
settings:settings:readÅtkomst till inställningar
capability:capability:registerRegistrering av funktioner

Jokerteckenbehörigheter stöds: network:* matchar alla behörighetskontroller av typen network:.

Inställningar

Inställningarna visas i Nebos gränssnitt under appens inställningspanel. Nebo sparar dem i databasen och skickar dem till din app via RPC-anropet Configure när de ändras.

Ditt inställningsschema ingår i appens annons i NeboAI:s appbutik. Appar med obligatoriska inställningar som inte är konfigurerade visar märket ”Behöver konfigureras” i gränssnittet.

TypBeskrivning
textTextfält med en rad
passwordMaskerat textfält
toggleBoolesk på/av-knapp
selectRullgardinsmeny med fördefinierade alternativ
numberNumeriskt fält
urlURL-fält 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"}
    ]
}

Krav på OAuth

Appar kan deklarera krav på OAuth-leverantörer. Nebos OAuth-mäklare sköter hela flödet — apparna får token automatiskt via RPC-anropet Configure.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
FältBeskrivning
providerOAuth-leverantör: "google", "microsoft", "github"
scopesArray med de OAuth-omfång som appen behöver

När användaren installerar appen ber Nebo användaren att godkänna de OAuth-omfång som krävs. Appen får förnyade token via RPC-anropet Configure utan att själv hantera OAuth-flödet.

Miljövariabler

Din apps process får en sanerad miljö. Alla hemligheter tas bort. Du får:

VariabelVärde
NEBO_APP_DIRAppens installationskatalog
NEBO_APP_SOCKSökväg till Unix-socketen som ska skapas
NEBO_APP_IDApp-ID från manifestet
NEBO_APP_NAMEAppnamn från manifestet
NEBO_APP_VERSIONAppversion från manifestet
NEBO_APP_DATASökväg till appens katalog data/
PATHSystemets PATH (skickas vidare)
HOMEAnvändarens hemkatalog (skickas vidare)
TMPDIRTemporär katalog (skickas vidare)

Viktigt: Din binärfil måste skapa en gRPC-server som lyssnar på Unix-socketen i NEBO_APP_SOCK. Nebo väntar i upp till 10 sekunder på att socketen ska dyka upp.

Appens startsekvens

  1. Nebo läser manifest.json och validerar den
  2. Hittar den körbara filen binary eller app i appkatalogen
  3. Letar efter markören .quarantined (vägrar starta appar i karantän)
  4. Kontroll av återkallelse (endast appar som distribueras av NeboAI)
  5. Verifiering av signatur (endast appar som distribueras av NeboAI, hoppas över i utvecklingsläge)
  6. Validering av binärfilen (avvisar symboliska länkar, skript, icke körbara filer och för stora filer)
  7. Rensar bort inaktuell socket från föregående körning
  8. Skapar katalogen data/ för lagring i sandlåda
  9. Skapar loggfiler per app (logs/stdout.log, logs/stderr.log)
  10. Startar binärfilen med sanerad miljö och isolerad processgrupp
  11. Väntar på att Unix-socketen ska dyka upp (exponentiell backoff, högst 10 sekunder)
  12. Ansluter via gRPC över Unix-socketen
  13. Skapar funktionsspecifika gRPC-klienter utifrån provides
  14. Kör hälsokontroll
  15. Registrerar funktioner hos AI-medarbetaren (verktyg, gateway, kommunikation osv.)

Verktygsappar

Deklarera "provides": ["tool:my_tool_name"] i ditt manifest.

STRAP-mönstret

Alla verktygsappar för Nebo måste använda STRAP (Single Tool Resource Action Pattern) för sitt schema och sin routning av körningar. Det är samma mönster som Nebo använder internt för att samla över 35 enskilda verktyg i 4 domänverktyg — vilket minskar LLM-kontextens overhead med cirka 80 %.

Grundidé: I stället för att registrera flera verktyg (get_events, check_availability, suggest_slots) registrerar du ETT verktyg med fälten action (och eventuellt resource) som skickar vidare till rätt hanterare.

Exempel med en resurs (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")

Exempel med flera resurser (projekthanterare):

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 för schemat:

  1. Ta alltid med ett action-fält som en obligatorisk strängenum
  2. Lägg bara till ett resource-fält (obligatorisk strängenum) om ditt verktyg hanterar flera olika resurstyper
  3. Alla andra fält är åtgärdsspecifika parametrar
  4. Beskrivningen av action-enumen ska lista alla tillgängliga åtgärder

Därför är STRAP viktigt:

  • LLM:er lär sig routningsmönstret för action en gång och generaliserar det till alla operationer
  • Verktygsdefinitioner tar upp cirka 6 % av kontexten — STRAP minskar det med 80 %
  • Nya operationer är bara tillägg i enumen, inte nya verktygsregistreringar
  • Fungerar likadant med molnbaserade och lokala modeller

Go-exempel — Kalkylatorverktyg

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": []
}

Bygg och installera:

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-exempel

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-exempel

#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;
}

Kanalappar

Deklarera "provides": ["channel:my_channel"] och "permissions": ["channel:send"].

Kanalappar kopplar externa meddelandeplattformar (Telegram, Discord, Slack osv.) till Nebos AI-medarbetare. När en användare skickar ett meddelande på den externa plattformen strömmar din app det till Nebo via Receive. När AI-medarbetaren vill svara anropar Nebo din apps Send.

Så fungerar det

  1. Nebo anropar ID() för att hämta kanalens unika identifierare
  2. Nebo anropar Connect() med konfigurationen från appens inställningar
  3. Nebo öppnar en Receive()-ström — din app skickar inkommande meddelanden varje gång en användare skriver till boten
  4. Inkommande meddelanden skickas till AI-medarbetarens huvudsakliga konversationsfält
  5. När AI-medarbetaren vill skicka ett meddelande anropar Nebo Send() med meddelandekuvertet v1
  6. Vid avstängning anropar Nebo Disconnect()

Meddelandekuvert v1

Alla kanalmeddelanden — inkommande och utgående — använder det gemensamma meddelandekuvertet:

{
  "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"
}
FältTypBeskrivning
message_idUUID v7Tidsordnat unikt ID
channel_id{type}:{platform_id}Routningsbar kanalidentifierare
senderobjectBotens identitet — namn, roll, botId
textstringMeddelandetext
attachmentsarrayFiler, bilder, ljud
reply_toUUID v7ID för överordnat meddelande vid trådning
actionsarrayInteraktiva knappar/tangentbord
platform_databytesOgenomskinlig vidarebefordran för plattformsspecifika funktioner
timestampISO 8601Utgivaren anger detta

Design i två lager: De gemensamma fälten (text, bilagor, svar, åtgärder) täcker 90 % av de meddelanden som medarbetare initierar. Plattformsspecifika funktioner läggs i platform_data — ditt plugin översätter dem till och från plattformens eget format.

Konversationsströmmar

Kanalmeddelanden skickas över separata konversationsströmmar per kanal för isolering:

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

Go-exempel — 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
        }
    ]
}

Fler funktioner

Kommunikationsapp

Deklarera "provides": ["comm"] och "permissions": ["comm:*"]. Kommunikationsappar gör det möjligt för AI-medarbetare att kommunicera med varandra.

FältBeskrivning
fromAvsändarens medarbetar-ID
toMottagarens medarbetar-ID
topicMeddelandets ämne/kanal
type"message", "mention", "proposal", "command", "info", "task"
contentMeddelandetext

Viktiga beteenden:

  • Register annonserar den här AI-medarbetaren i nätverket tillsammans med dess funktioner
  • Subscribe/Unsubscribe hanterar prenumerationer på ämnen
  • Receive strömmar inkommande meddelanden (serverströmning, precis som kanaler)
  • Endast en kommunikationsapp kan vara aktiv åt gången

Gateway-app

En gateway-app skickar LLM-anrop vidare till modeller. Deklarera "provides": ["gateway"] och "permissions": ["network:outbound", "user:token"].

GatewayRequest innehåller meddelanden, verktyg, systemprompt, max antal token, temperatur och en UserContext (JWT-token om behörigheten user:token har beviljats).

Typer av GatewayEvent:

TypInnehållBeskrivning
"text"TextstyckeStrömmad texttoken
"tool_call"JSONModellen vill anropa ett verktyg
"thinking"TextstyckeUtökat tänkande/resonemang
"error"FelmeddelandeNågot gick fel
"done"TomStrömmen är klar

UI-app

En UI-app erbjuder ett eget konfigurationsgränssnitt som öppnas i Nebos inbyggda webbläsarfönster. Deklarera "provides": ["ui"]. Till skillnad från det automatiska inställningsformuläret (som Nebo renderar från settings i ditt manifest) levererar en UI-app ett helt eget HTML/CSS/JS-gränssnitt.

Din app levereras med en katalog ui/ som innehåller statiska webbresurser (HTML, CSS, JS — oftast en SPA med index.html). Nebo serverar filerna direkt och skickar API-anrop vidare till din app via gRPC.

SökvägMekanismSyfte
GET /api/v1/apps/{id}/ui/*Statisk filserverServerar filer från din katalog ui/ (SPA-reserv till index.html)
ANY /api/v1/apps/{id}/api/*gRPC-proxySkickar HTTP-anrop vidare till din apps UIService.HandleRequest()

SDK:n kapslar in en vanlig net/http.ServeMux så att du skriver vanliga HTTP-hanterare i Go — SDK:n sköter gRPC-bryggningen automatiskt.

Go-exempel — Instrumentpanel:

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 skulle göra fetch-anrop till /api/v1/apps/com.example.dashboard/api/status, som skickas vidare till din mux-hanterare.

Schemaläggningsapp

En schemaläggningsapp ersätter Nebos inbyggda cron-schemaläggare. Deklarera "provides": ["schedule"] och "permissions": ["schedule:create"].

När din schemaläggningsapp startar skickar Nebo all schemaläggning via din app i stället för den inbyggda cron-motorn. Om din app kraschar går Nebo automatiskt tillbaka till den inbyggda motorn.

  • Din app äger schemats tillstånd — Nebo sparar inga scheman i sin egen databas när en schemaläggningsapp är aktiv
  • Standard-CRUD: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers är ett serverströmmande RPC-anrop — din app skickar ett utlösarmeddelande varje gång ett schema utlöses
  • Endast en schemaläggningsapp kan vara aktiv åt gången

Appar med flera funktioner

En app kan tillhandahålla flera funktioner. Till exempel en instrumentpanelsapp med både ett verktyg och ett gränssnitt:

{
    "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())

Paketering

Formatet .napp

För distribution via NeboAI paketerar du din app som en .napp-fil (ett tar.gz-arkiv):

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

Obligatoriska filer:

FilMaxstorlekBeskrivning
manifest.json1 MBAppens metadata
binary eller app500 MBKörbar fil
signatures.json1 MBEd25519-signaturer
TOOL.md1 MBVerktygsinstruktioner för AI-medarbetaren

Säkerhetsregler vid uppackning:

  • Ingen katalogtraversering (../ avvisas)
  • Inga symboliska länkar (avvisas)
  • Inga absoluta sökvägar (avvisas)
  • Endast tillåtna filnamn accepteras

Signaturer

NeboAI signerar appar med Ed25519. Formatet för 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 utvecklingsläge (ingen NeboAI-URL konfigurerad) hoppas signaturverifieringen över helt. Du behöver ingen signatures.json för lokal utveckling.

Publicering

När din app fungerar lokalt kan du publicera den via NeboAI så att den distribueras till alla Nebo-användare.

Skapa utvecklarkonto

  1. Registrera ett NeboAI-konto på POST /api/v1/owners/register
  2. Logga in för att få en JWT-token: POST /api/v1/owners/login
  3. Skapa ett utvecklarkonto: POST /api/v1/developer/accounts

Inskickningsflöde

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

Steg 1: Skapa 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"
  }'

Steg 2: Ladda upp plattformsbinärer

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"

Ladda upp en binärfil per plattform: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Steg 3: Skicka in för granskning

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

Granskningsprocessen

  1. Automatisk skanning — binärfilerna skannas via VirusTotal
  2. Administratörsgranskning — NeboAI-teamet granskar metadata, manifest och skanningsresultat
  3. Vid godkännande — NeboAI signerar appen med Ed25519 och publicerar den
  4. Vid avslag — du får ett skäl och kan rätta till och skicka in igen

Mål för granskningstid: <24 timmar.

Skicka uppdateringar

  1. Uppdatera appens version: PUT /api/v1/developer/apps/{id} med den nya versionen
  2. Ladda upp nya binärfiler för varje plattform
  3. Skicka in för granskning igen

Varje uppdatering går igenom samma granskningsprocess. Tidigare versioner förblir tillgängliga tills den nya versionen har godkänts.

Butiksmetadata

FältBeskrivning
categoryt.ex. produktivitet, kommunikation, utvecklarverktyg
iconURL till appikon
visibilitypublic eller private
descriptionKan vara längre/utförligare än beskrivningen i manifestet

Utvecklarflöde

Lokal utveckling

Ingen paketering krävs för lokal utveckling:

  1. Skapa din appkatalog:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Skriv din manifest.json och din kod
  3. Bygg din binär:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo upptäcker den nya katalogen automatiskt (eller starta om Nebo)
  5. Bygg om binärfilen efter kodändringar — filbevakaren startar om appen

Visa loggar

Appens stdout/stderr samlas i loggfiler per 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

Beständig data

Använd katalogen data/ (finns även som miljövariabeln NEBO_APP_DATA) för filer som din app behöver spara. Katalogen finns kvar vid appuppdateringar och karantän.

Felsökningstips

  • Om din app inte startar, leta efter fel i logs/stderr.log
  • Se till att binärfilen är körbar (chmod +x binary)
  • Se till att du lyssnar på Unix-socketens sökväg från NEBO_APP_SOCK
  • Socketen måste vara redo inom 10 sekunder efter start
  • Använd NEBO_APP_DATA för lagring, inte hårdkodade sökvägar
  • Skriv till stderr för felsökningsloggar (samlas i logs/stderr.log)

Verifiera

# 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

Avinstallera

nebo apps uninstall com.example.myapp

Färdigheter

Vad färdigheter är

Färdigheter är instruktioner som formar hur Nebo beter sig under en konversation. När en färdighet är aktiv läggs dess innehåll direkt in i systemprompten — och styr AI-medarbetarens ton, metodik, fackkunskap och verktygsanvändning under sessionen.

Färdigheter är inte kod. De är markdown-dokument med YAML-metadata. Ingen kompilering, ingen binärfil, ingen gRPC. En färdighet är en SKILL.md-fil i en katalog. Det är allt.

Färdigheter är kontextuella och tillfälliga. De aktiveras när de är relevanta (via utlösarmatchning eller manuell inläsning), finns kvar några turer och löper ut när de inte längre behövs. Det håller AI-medarbetarens kontext smal — bara den vägledning som är viktig just nu finns i prompten.

Färdigheter kompletterar appar. Appar ger körbara funktioner (verktyg, kanaler, gateways). Färdigheter ger vägledning för samordning — hur verktygen används på bästa sätt. En kalenderapp ger Nebo förmågan att läsa och skriva händelser. En färdighet för ”mötesförberedelser” talar om för Nebo hur den ska förbereda möten med kalenderappen, e-post och webbsökning tillsammans.

Färdigheter jämfört med appar

FärdigheterAppar
FormatMarkdown (SKILL.md)Kompilerad binärfil (.napp)
KörningLäggs in i systempromptenProcess i sandlåda via gRPC
TillhandahållerVägledning för beteende, metodikVerktyg, kanaler, UI-paneler
LivslängdGäller per session, löper ut efter TTLAlltid igång
SkapandeSkriv en markdown-filSkriv, kompilera, signera, paketera
SäkerhetInga behörigheter behövsSandlåda där allt är nekat som standard

Snabbstart

Skapa en katalog i din Nebo-mapp för färdigheter 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 bevakar färdighetskatalogen med fsnotify. Din färdighet är tillgänglig direkt — ingen omstart behövs. Säg något som matchar en utlösare så aktiveras den automatiskt.

Eller be Nebo direkt: ”Skapa en färdighet för att skriva blogginlägg” — Nebo skriver SKILL.md-filen åt dig.

Formatet för SKILL.md

Varje färdighet är en enda SKILL.md-fil med två delar: YAML-frontmatter mellan ----markörer och en markdown-del (själva instruktionerna som läggs in i systemprompten).

FältObligatorisktStandardBeskrivning
nameJa—Unik identifierare (blir slug)
descriptionJa—Beskrivning på en rad som visas i färdighetskatalogen
versionNej"1.0.0"Semver för att spåra uppdateringar
authorNej—Färdighetens upphovsperson
priorityNej0Högre = matchas först (100+ för kritiska åsidosättningar)
max_turnsNej4Antal inaktiva turer innan den löper ut automatiskt
triggersNej[]Fraser som aktiverar färdigheten automatiskt (delsträngsmatchning, skiftlägesokänslig)
toolsNej[]Verktyg som färdigheten räknar med att använda (informativt)
dependenciesNej[]Andra färdigheter som måste vara installerade
tagsNej[]För kategorisering och upptäckt
platformNej[]Plattformar som stöds: macos, linux, windows (tomt = alla)

Så aktiveras färdigheter

Färdigheter aktiveras i två steg: först ett tips, sedan ett anrop.

Steg 1: Matchning av utlösare — Varje gång en användare skickar ett meddelande söker Nebo igenom alla registrerade färdigheter efter matchande utlösare. Matchande färdigheter visas som tips i systemprompten. AI-medarbetaren ser tipset och bestämmer om färdigheten ska anropas.

Steg 2: Anrop — AI-medarbetaren anropar en färdighet så här:

skill(name: "code-review")

Det returnerar hela SKILL.md-mallen som verktygsresultat, registrerar anropet och lägger in mallen i systemprompten igen under följande turer.

TTL och utgång:

  • Automatiskt matchade färdigheter: 4 inaktiva turer (kan ställas in via max_turns)
  • Manuellt inlästa färdigheter: 6 inaktiva turer
  • Ett nytt anrop nollställer timern
  • Absolut tak: högst 4 aktiva färdigheter per session
  • Teckenbudget: aktiva färdigheters sammanlagda innehåll är begränsat till 16 000 tecken

Hantera färdigheter

AI-medarbetaren kan hantera färdigheter med verktyget skill:

ÅtgärdBeskrivningExempel
catalogLista alla tillgängliga färdigheterskill(action: "catalog")
loadAktivera för den här sessionenskill(name: "code-review", action: "load")
unloadInaktivera en färdighetskill(name: "code-review", action: "unload")
createSkapa en ny färdighet på diskskill(action: "create", content: "...")
updateUppdatera en befintlig färdighetskill(name: "my-skill", action: "update", content: "...")
deleteTa bort en färdighet från diskenskill(name: "my-skill", action: "delete")

Skriva bra färdigheter

En bra färdighetsmall har:

  1. En tydlig rubrik — talar om för AI-medarbetaren vilket läge den är i
  2. Grundprinciper — de beteenderegler som inte går att förhandla bort
  3. Metodik — ett steg-för-steg-arbetssätt för vanliga situationer
  4. Exempel — konkreta mönster från användarmeddelande till svar
  5. Antimönster — vad man INTE ska göra (modeller lär sig bra av negativa exempel)

Tips: Varje färdighet ska göra en sak bra. Skapa inte en färdighet för ”allmän programmering” — skapa code-review, debugging och api-design som separata färdigheter. AI-medarbetaren kan ha flera aktiva samtidigt.

Medföljande färdigheter

Nebo levereras med färdigheter som täcker vanliga användningsfall:

FärdighetPrioritetBeskrivning
onboarding100Välkomnande av nya användare och insamling av profil
best-friend50Personlighetsfärdighet — avslappnad, lojal, rakt på sak
debugging25Systematisk felsökningsmetodik
api-design15Bästa praxis för design av RESTful-API:er
code-review10Strukturerad kodgranskning med allvarlighetsnivåer
database-expert10Databasdesign, frågor, optimering
git-workflow10Git-grenar, commits, PR-flöden
security-audit10Säkerhetsanalys och upptäckt av sårbarheter

De fungerar både som användbara standardval och som referensexempel när du skapar egna färdigheter.

Referens

Proto-filer

Proto-filerna ligger i proto/apps/v0/. SDK:erna levereras med färdiggenererad kod, så du behöver inte protoc för vanlig utveckling.

FilTjänstViktiga RPC:er
v0/common.proto(endast meddelanden)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

Varje tjänst innehåller RPC-anropen HealthCheck och Configure. SDK:n hanterar båda automatiskt.

Proto-typer för kanaler

MeddelandetypBeskrivning
ChannelSendRequestKuvert för utgående meddelanden med message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponsePlattformens meddelande-ID för trådning
InboundMessageKuvert för inkommande meddelanden med alla gemensamma fält + tidsstämpel
MessageSenderBotens identitet (name, role, botId) — berikas av mäklaren
AttachmentBilaga i form av fil/bild/ljud (type, url, filename, size)
MessageActionInteraktiv knapp/tangentbordsåtgärd (label, callback_id)

Botidentitet och roller

Nebos bottar har en identitetsmodell med tre axlar:

  • creature — Vad boten är (arketyp): ”Kvicktänkt strateg”, ”Noggrann forskare”
  • role — Hur den förhåller sig till användaren (relation): ”Vän”, ”COO”, ”Mentor”
  • vibe — Dess energi (kommunikationsstil): ”Avslappnad men med åsikter”, ”Varm och uppmuntrande”

När ditt kanalplugin tar emot ett utgående meddelande innehåller fältet sender botens name och role. Använd dem för att formatera visningsnamnet på din plattform. Rollen är ingen jobbtitel — den beskriver en relation. ”Vän”, ”Son” och ”Mentor” är giltiga roller lika väl som ”COO” och ”DevLead”.