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.
| Status | Sprog |
|---|---|
| Understøttet | Go (anbefalet), Rust, C/C++, Zig |
| Afvist | Python, 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
- Opret
manifest.jsonmedid,name,version,provides - Skriv
TOOL.md, der beskriver, hvordan AI-medarbejderen skal bruge dit værktøj - Installér SDK'et (
go get github.com/neboloop/nebo-sdk-go) - Implementér handler-interfacet for din funktion (
ToolHandler,ChannelHandlerosv.) - Registrér handleren, og kald
app.Run() - Byg en native binær (
go build -o binary .) - Læg binær + manifest.json + TOOL.md i mappen
apps/<your-app-id>/ - 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:
| Felt | Beskrivelse |
|---|---|
id | Identifikator med omvendt domæne (f.eks. com.mycompany.myapp) |
name | Navn, der kan læses af mennesker |
version | Semver-streng |
provides | Mindst én funktion (se nedenfor) |
Valgfrie felter:
| Felt | Standard | Beskrivelse |
|---|---|---|
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:
| Funktion | gRPC-tjeneste | Beskrivelse |
|---|---|---|
gateway | GatewayService | Routing af LLM-modeller |
tool:<name> | ToolService | Et navngivet værktøj til AI-medarbejderen |
channel:<name> | ChannelService | En beskedkanal |
comm | CommService | Kommunikation mellem AI-medarbejdere |
ui | UIService | Tilpasset grænseflade med HTTP-proxy |
schedule | ScheduleService | Tilpasset planlægning |
vision | ToolService | Billedbehandling |
browser | ToolService | Browserautomatisering |
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æfiks | Eksempler | Beskrivelse |
|---|---|---|
network: | network:outbound, network:* | Netværksadgang |
filesystem: | filesystem:read, filesystem:write | Adgang til filsystemet |
memory: | memory:read, memory:write | Adgang til AI-medarbejderens hukommelse |
session: | session:read | Samtalesessioner |
tool: | tool:shell, tool:file | Brug andre værktøjer |
shell: | shell:exec | Kørsel af shellkommandoer |
channel: | channel:send, channel:* | Kanaloperationer |
comm: | comm:send, comm:* | Kommunikation mellem AI-medarbejdere |
model: | model:chat | Adgang til AI-modeller |
user: | user:token | Modtag brugerens JWT i anmodninger |
schedule: | schedule:create | Styring af cron-job |
database: | database:query | Databaseadgang |
storage: | storage:read, storage:write | Vedvarende lagring |
context: | context:read | Adgang til AI-medarbejderens kontekst |
subagent: | subagent:spawn | Operationer med underagenter |
lane: | lane:enqueue | Lane-operationer |
notification: | notification:send | Push-notifikationer |
embedding: | embedding:search | Adgang til vektor-embeddings |
skill: | skill:invoke | Kald af færdigheder |
advisor: | advisor:consult | Adgang til rådgiversystemet |
mcp: | mcp:connect | Adgang til MCP-servere |
voice: | voice:record | Adgang til stemme/lyd |
browser: | browser:navigate | Browserautomatisering |
oauth: | oauth:google, oauth:* | Adgang til OAuth-tokens |
settings: | settings:read | Adgang til indstillinger |
capability: | capability:register | Registrering 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.
| Type | Beskrivelse |
|---|---|
text | Tekstfelt med én linje |
password | Maskeret tekstfelt |
toggle | Boolesk tænd/sluk-kontakt |
select | Rulleliste med foruddefinerede valg |
number | Talfelt |
url | URL-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"]
}
]
} | Felt | Beskrivelse |
|---|---|
provider | OAuth-udbyder: "google", "microsoft", "github" |
scopes | Array 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:
| Variabel | Værdi |
|---|---|
NEBO_APP_DIR | Appens installationsmappe |
NEBO_APP_SOCK | Sti til den Unix-socket, der skal oprettes |
NEBO_APP_ID | App-ID fra manifestet |
NEBO_APP_NAME | Appnavn fra manifestet |
NEBO_APP_VERSION | Appversion fra manifestet |
NEBO_APP_DATA | Sti til appens mappe data/ |
PATH | Systemets PATH (videregives) |
HOME | Brugerens hjemmemappe (videregives) |
TMPDIR | Midlertidig 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
- Nebo læser
manifest.jsonog validerer den - Finder programmet
binaryellerappi appens mappe - Tjekker for markøren
.quarantined(nægter at starte apps i karantæne) - Tjek for tilbagekaldelse (kun apps distribueret af NeboAI)
- Verificering af signatur (kun apps distribueret af NeboAI, springes over under udvikling)
- Validering af binær (afviser symlinks, scripts, ikke-eksekverbare filer og for store filer)
- Rydder en gammel socket fra forrige kørsel op
- Opretter mappen
data/til lagring i sandkassen - Opsætter logfiler pr. app (
logs/stdout.log,logs/stderr.log) - Starter binæren med et renset miljø og isolering af procesgruppe
- Venter på, at Unix-socketten dukker op (eksponentiel backoff, højst 10 sekunder)
- Forbinder via gRPC over Unix-socketten
- Opretter funktionsspecifikke gRPC-klienter ud fra
provides - Kører sundhedstjek
- 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:
- Medtag altid feltet
actionsom en påkrævet streng-enum - Tilføj feltet
resource(påkrævet streng-enum) kun, hvis dit værktøj håndterer flere forskellige ressourcetyper - Alle andre felter er parametre, der hører til den enkelte handling
- Beskrivelsen af enum'en
actionskal 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
- Nebo kalder
ID()for at få din kanals unikke identifikator - Nebo kalder
Connect()med konfiguration fra din apps indstillinger - Nebo åbner en
Receive()-stream — din app sender indgående beskeder, hver gang en bruger skriver til botten - Indgående beskeder sendes til AI-medarbejderens primære samtalelane
- Når AI-medarbejderen vil sende en besked, kalder Nebo
Send()med v1-beskedkonvolutten - 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"
} | Felt | Type | Beskrivelse |
|---|---|---|
message_id | UUID v7 | Tidsordnet unikt ID |
channel_id | {type}:{platform_id} | Kanalidentifikator, der kan routes |
sender | object | Botidentitet — navn, rolle, botId |
text | string | Beskedens indhold |
attachments | array | Filer, billeder, lyd |
reply_to | UUID v7 | Overordnet besked-ID til tråde |
actions | array | Interaktive knapper/tastaturer |
platform_data | bytes | Uigennemsigtig videregivelse til platformsspecifikke funktioner |
timestamp | ISO 8601 | Udgiveren 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.
| Felt | Beskrivelse |
|---|---|
from | Afsenderens medarbejder-ID |
to | Modtagerens medarbejder-ID |
topic | Beskedens emne/kanal |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Beskedens indhold |
Vigtig adfærd:
Registerannoncerer denne AI-medarbejder på netværket med dens funktionerSubscribe/Unsubscribestyrer abonnementer på emnerReceivestreamer 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:
| Type | Indhold | Beskrivelse |
|---|---|---|
"text" | Tekststykke | Streamet teksttoken |
"tool_call" | JSON | Modellen vil kalde et værktøj |
"thinking" | Tekststykke | Udvidet tænkning/ræsonnement |
"error" | Fejlbesked | Noget gik galt |
"done" | Tom | Streamen 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.
| Sti | Mekanisme | Formål |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Statisk filserver | Serverer filer fra din mappe ui/ (SPA-fallback til index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC-proxy | Sender 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 Triggerser 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:
| Fil | Maks. størrelse | Beskrivelse |
|---|---|---|
manifest.json | 1 MB | Appens metadata |
binary eller app | 500 MB | Program |
signatures.json | 1 MB | Ed25519-signaturer |
TOOL.md | 1 MB | Væ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
- Registrér en NeboAI-konto på
POST /api/v1/owners/register - Log ind for at få et JWT-token:
POST /api/v1/owners/login - 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
- Automatisk scanning — binære filer scannes via VirusTotal
- Gennemgang af administrator — NeboAI-teamet gennemgår metadata, manifest og scanningsresultater
- Ved godkendelse — NeboAI signerer appen med Ed25519 og udgiver den
- Ved afvisning — du får en begrundelse og kan rette og indsende igen
Mål for gennemgangstid: <24 timer.
Udgiv opdateringer
- Opdater appens version:
PUT /api/v1/developer/apps/{id}med den nye version - Upload nye binære filer til hver platform
- 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
| Felt | Beskrivelse |
|---|---|
category | f.eks. productivity, communication, developer-tools |
icon | URL til appikon |
visibility | public eller private |
description | Kan være længere/mere udførlig end beskrivelsen i manifestet |
Udviklingsforløb
Lokal udvikling
Ingen pakning nødvendig til lokal udvikling:
- Opret din app-mappe:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Skriv din
manifest.jsonog din kode - Byg din binærfil:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo opdager automatisk den nye mappe (eller genstart Nebo)
- 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.logfor 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_DATAtil 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ærdigheder | Apps | |
|---|---|---|
| Format | Markdown (SKILL.md) | Kompileret binær (.napp) |
| Kørsel | Indsættes i systemprompten | Proces i sandkasse over gRPC |
| Leverer | Vejledning i adfærd, metode | Værktøjer, kanaler, UI-paneler |
| Levetid | Gælder for sessionen, udløber efter TTL | Kører altid |
| Oprettelse | Skriv en markdown-fil | Skriv, kompilér, signér, pak |
| Sikkerhed | Ingen tilladelser nødvendige | Sandkasse 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).
| Felt | Påkrævet | Standard | Beskrivelse |
|---|---|---|---|
name | Ja | — | Unik identifikator (bliver til slug) |
description | Ja | — | Beskrivelse på én linje, der vises i kataloget over færdigheder |
version | Nej | "1.0.0" | Semver til at følge opdateringer |
author | Nej | — | Færdighedens forfatter |
priority | Nej | 0 | Højere = matches først (100+ for kritiske tilsidesættelser) |
max_turns | Nej | 4 | Antal inaktive ture før automatisk udløb |
triggers | Nej | [] | Fraser, der automatisk aktiverer denne færdighed (match på delstreng, uden forskel på store og små bogstaver) |
tools | Nej | [] | Værktøjer, som færdigheden forventer at bruge (til orientering) |
dependencies | Nej | [] | Andre færdigheder, der skal være installeret |
tags | Nej | [] | Til kategorisering og opdagelse |
platform | Nej | [] | 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:
| Handling | Beskrivelse | Eksempel |
|---|---|---|
catalog | Vis alle tilgængelige færdigheder | skill(action: "catalog") |
load | Aktivér for denne session | skill(name: "code-review", action: "load") |
unload | Deaktivér en færdighed | skill(name: "code-review", action: "unload") |
create | Opret en ny færdighed på disken | skill(action: "create", content: "...") |
update | Opdatér en eksisterende færdighed | skill(name: "my-skill", action: "update", content: "...") |
delete | Slet en færdighed fra disken | skill(name: "my-skill", action: "delete") |
Skriv gode færdigheder
En god færdighedsskabelon har:
- En tydelig overskrift — fortæller AI-medarbejderen, hvilken tilstand den er i
- Grundprincipper — de adfærdsregler, der ikke kan forhandles
- Metode — trinvis fremgangsmåde for almindelige scenarier
- Eksempler — konkrete mønstre fra brugerbesked til svar
- 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ærdighed | Prioritet | Beskrivelse |
|---|---|---|
onboarding | 100 | Velkomst til nye brugere og indsamling af profil |
best-friend | 50 | Personlighedsfærdighed — afslappet, loyal, ærlig snak |
debugging | 25 | Systematisk metode til fejlfinding |
api-design | 15 | Bedste praksis for design af RESTful API'er |
code-review | 10 | Struktureret kodegennemgang med alvorlighedsniveauer |
database-expert | 10 | Databasedesign, forespørgsler, optimering |
git-workflow | 10 | Git-branches, commits, PR-workflows |
security-audit | 10 | Sikkerhedsanalyse 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.
| Fil | Tjeneste | Vigtige RPC'er |
|---|---|---|
v0/common.proto | (kun beskeder) | HealthCheckRequest/Response, SettingsMap, UserContext, Empty |
v0/tool.proto | ToolService | Name, Description, Schema, Execute, RequiresApproval, Configure |
v0/channel.proto | ChannelService | ID, Connect, Disconnect, Send, Receive (stream), Configure |
v0/comm.proto | CommService | Name, Version, Connect, Disconnect, Send, Subscribe, Register, Receive (stream), Configure |
v0/gateway.proto | GatewayService | HealthCheck, Stream (stream), Poll, Cancel, Configure |
v0/ui.proto | UIService | HealthCheck, HandleRequest, Configure |
v0/schedule.proto | ScheduleService | HealthCheck, 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
| Beskedtype | Beskrivelse |
|---|---|
ChannelSendRequest | Konvolut til udgående besked med message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | Platformens besked-ID til tråde |
InboundMessage | Konvolut til indgående besked med alle fælles felter + tidsstempel |
MessageSender | Botidentitet (name, role, botId) — beriget af brokeren |
Attachment | Vedhæftet fil/billede/lyd (type, url, filename, size) |
MessageAction | Interaktiv 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".