Ö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.
| Status | Språk |
|---|---|
| Stöds | Go (rekommenderas), Rust, C/C++, Zig |
| Avvisas | Python, 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
- Skapa
manifest.jsonmedid,name,version,provides - Skriv
TOOL.mdsom beskriver hur AI-medarbetaren ska använda ditt verktyg - Installera SDK:n (
go get github.com/neboloop/nebo-sdk-go) - Implementera hanterargränssnittet för din funktion (
ToolHandler,ChannelHandlerosv.) - Registrera hanteraren och anropa
app.Run() - Bygg en inbyggd binärfil (
go build -o binary .) - Lägg binärfilen + manifest.json + TOOL.md i katalogen
apps/<your-app-id>/ - 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ält | Beskrivning |
|---|---|
id | Identifierare i omvänd domänform (t.ex. com.mycompany.myapp) |
name | Läsbart namn |
version | Semver-sträng |
provides | Minst en funktion (se nedan) |
Valfria fält:
| Fält | Standard | Beskrivning |
|---|---|---|
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:
| Funktion | gRPC-tjänst | Beskrivning |
|---|---|---|
gateway | GatewayService | Routning av LLM-modeller |
tool:<name> | ToolService | Ett namngivet verktyg för AI-medarbetaren |
channel:<name> | ChannelService | En meddelandekanal |
comm | CommService | Kommunikation mellan AI-medarbetare |
ui | UIService | Eget gränssnitt med HTTP-proxy |
schedule | ScheduleService | Egen schemaläggning |
vision | ToolService | Bildbehandling |
browser | ToolService | Webblä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.
| Prefix | Exempel | Beskrivning |
|---|---|---|
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:read | Konversationssessioner |
tool: | tool:shell, tool:file | Använda andra verktyg |
shell: | shell:exec | Kö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:token | Ta emot användarens JWT i anrop |
schedule: | schedule:create | Hantering av cron-jobb |
database: | database:query | Databasåtkomst |
storage: | storage:read, storage:write | Beständig lagring |
context: | context:read | Åtkomst till AI-medarbetarens kontext |
subagent: | subagent:spawn | Operationer för underagenter |
lane: | lane:enqueue | Operationer för körfält |
notification: | notification:send | Push-notiser |
embedding: | embedding:search | Åtkomst till vektorinbäddningar |
skill: | skill:invoke | Anrop 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:navigate | Webbläsarautomation |
oauth: | oauth:google, oauth:* | Åtkomst till OAuth-token |
settings: | settings:read | Åtkomst till inställningar |
capability: | capability:register | Registrering 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.
| Typ | Beskrivning |
|---|---|
text | Textfält med en rad |
password | Maskerat textfält |
toggle | Boolesk på/av-knapp |
select | Rullgardinsmeny med fördefinierade alternativ |
number | Numeriskt fält |
url | URL-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ält | Beskrivning |
|---|---|
provider | OAuth-leverantör: "google", "microsoft", "github" |
scopes | Array 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:
| Variabel | Värde |
|---|---|
NEBO_APP_DIR | Appens installationskatalog |
NEBO_APP_SOCK | Sökväg till Unix-socketen som ska skapas |
NEBO_APP_ID | App-ID från manifestet |
NEBO_APP_NAME | Appnamn från manifestet |
NEBO_APP_VERSION | Appversion från manifestet |
NEBO_APP_DATA | Sökväg till appens katalog data/ |
PATH | Systemets PATH (skickas vidare) |
HOME | Användarens hemkatalog (skickas vidare) |
TMPDIR | Temporä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
- Nebo läser
manifest.jsonoch validerar den - Hittar den körbara filen
binaryellerappi appkatalogen - Letar efter markören
.quarantined(vägrar starta appar i karantän) - Kontroll av återkallelse (endast appar som distribueras av NeboAI)
- Verifiering av signatur (endast appar som distribueras av NeboAI, hoppas över i utvecklingsläge)
- Validering av binärfilen (avvisar symboliska länkar, skript, icke körbara filer och för stora filer)
- Rensar bort inaktuell socket från föregående körning
- Skapar katalogen
data/för lagring i sandlåda - Skapar loggfiler per app (
logs/stdout.log,logs/stderr.log) - Startar binärfilen med sanerad miljö och isolerad processgrupp
- Väntar på att Unix-socketen ska dyka upp (exponentiell backoff, högst 10 sekunder)
- Ansluter via gRPC över Unix-socketen
- Skapar funktionsspecifika gRPC-klienter utifrån
provides - Kör hälsokontroll
- 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:
- Ta alltid med ett
action-fält som en obligatorisk strängenum - Lägg bara till ett
resource-fält (obligatorisk strängenum) om ditt verktyg hanterar flera olika resurstyper - Alla andra fält är åtgärdsspecifika parametrar
- 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
actionen 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
- Nebo anropar
ID()för att hämta kanalens unika identifierare - Nebo anropar
Connect()med konfigurationen från appens inställningar - Nebo öppnar en
Receive()-ström — din app skickar inkommande meddelanden varje gång en användare skriver till boten - Inkommande meddelanden skickas till AI-medarbetarens huvudsakliga konversationsfält
- När AI-medarbetaren vill skicka ett meddelande anropar Nebo
Send()med meddelandekuvertet v1 - 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ält | Typ | Beskrivning |
|---|---|---|
message_id | UUID v7 | Tidsordnat unikt ID |
channel_id | {type}:{platform_id} | Routningsbar kanalidentifierare |
sender | object | Botens identitet — namn, roll, botId |
text | string | Meddelandetext |
attachments | array | Filer, bilder, ljud |
reply_to | UUID v7 | ID för överordnat meddelande vid trådning |
actions | array | Interaktiva knappar/tangentbord |
platform_data | bytes | Ogenomskinlig vidarebefordran för plattformsspecifika funktioner |
timestamp | ISO 8601 | Utgivaren 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ält | Beskrivning |
|---|---|
from | Avsändarens medarbetar-ID |
to | Mottagarens medarbetar-ID |
topic | Meddelandets ämne/kanal |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Meddelandetext |
Viktiga beteenden:
Registerannonserar den här AI-medarbetaren i nätverket tillsammans med dess funktionerSubscribe/Unsubscribehanterar prenumerationer på ämnenReceiveströ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:
| Typ | Innehåll | Beskrivning |
|---|---|---|
"text" | Textstycke | Strömmad texttoken |
"tool_call" | JSON | Modellen vill anropa ett verktyg |
"thinking" | Textstycke | Utökat tänkande/resonemang |
"error" | Felmeddelande | Något gick fel |
"done" | Tom | Strö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äg | Mekanism | Syfte |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Statisk filserver | Serverar filer från din katalog ui/ (SPA-reserv till index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC-proxy | Skickar 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:
| Fil | Maxstorlek | Beskrivning |
|---|---|---|
manifest.json | 1 MB | Appens metadata |
binary eller app | 500 MB | Körbar fil |
signatures.json | 1 MB | Ed25519-signaturer |
TOOL.md | 1 MB | Verktygsinstruktioner 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
- Registrera ett NeboAI-konto på
POST /api/v1/owners/register - Logga in för att få en JWT-token:
POST /api/v1/owners/login - 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
- Automatisk skanning — binärfilerna skannas via VirusTotal
- Administratörsgranskning — NeboAI-teamet granskar metadata, manifest och skanningsresultat
- Vid godkännande — NeboAI signerar appen med Ed25519 och publicerar den
- 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
- Uppdatera appens version:
PUT /api/v1/developer/apps/{id}med den nya versionen - Ladda upp nya binärfiler för varje plattform
- 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ält | Beskrivning |
|---|---|
category | t.ex. produktivitet, kommunikation, utvecklarverktyg |
icon | URL till appikon |
visibility | public eller private |
description | Kan vara längre/utförligare än beskrivningen i manifestet |
Utvecklarflöde
Lokal utveckling
Ingen paketering krävs för lokal utveckling:
- Skapa din appkatalog:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Skriv din
manifest.jsonoch din kod - Bygg din binär:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo upptäcker den nya katalogen automatiskt (eller starta om Nebo)
- 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_DATAfö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ärdigheter | Appar | |
|---|---|---|
| Format | Markdown (SKILL.md) | Kompilerad binärfil (.napp) |
| Körning | Läggs in i systemprompten | Process i sandlåda via gRPC |
| Tillhandahåller | Vägledning för beteende, metodik | Verktyg, kanaler, UI-paneler |
| Livslängd | Gäller per session, löper ut efter TTL | Alltid igång |
| Skapande | Skriv en markdown-fil | Skriv, kompilera, signera, paketera |
| Säkerhet | Inga behörigheter behövs | Sandlå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ält | Obligatoriskt | Standard | Beskrivning |
|---|---|---|---|
name | Ja | — | Unik identifierare (blir slug) |
description | Ja | — | Beskrivning på en rad som visas i färdighetskatalogen |
version | Nej | "1.0.0" | Semver för att spåra uppdateringar |
author | Nej | — | Färdighetens upphovsperson |
priority | Nej | 0 | Högre = matchas först (100+ för kritiska åsidosättningar) |
max_turns | Nej | 4 | Antal inaktiva turer innan den löper ut automatiskt |
triggers | Nej | [] | Fraser som aktiverar färdigheten automatiskt (delsträngsmatchning, skiftlägesokänslig) |
tools | Nej | [] | Verktyg som färdigheten räknar med att använda (informativt) |
dependencies | Nej | [] | Andra färdigheter som måste vara installerade |
tags | Nej | [] | För kategorisering och upptäckt |
platform | Nej | [] | 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ärd | Beskrivning | Exempel |
|---|---|---|
catalog | Lista alla tillgängliga färdigheter | skill(action: "catalog") |
load | Aktivera för den här sessionen | skill(name: "code-review", action: "load") |
unload | Inaktivera en färdighet | skill(name: "code-review", action: "unload") |
create | Skapa en ny färdighet på disk | skill(action: "create", content: "...") |
update | Uppdatera en befintlig färdighet | skill(name: "my-skill", action: "update", content: "...") |
delete | Ta bort en färdighet från disken | skill(name: "my-skill", action: "delete") |
Skriva bra färdigheter
En bra färdighetsmall har:
- En tydlig rubrik — talar om för AI-medarbetaren vilket läge den är i
- Grundprinciper — de beteenderegler som inte går att förhandla bort
- Metodik — ett steg-för-steg-arbetssätt för vanliga situationer
- Exempel — konkreta mönster från användarmeddelande till svar
- 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ärdighet | Prioritet | Beskrivning |
|---|---|---|
onboarding | 100 | Välkomnande av nya användare och insamling av profil |
best-friend | 50 | Personlighetsfärdighet — avslappnad, lojal, rakt på sak |
debugging | 25 | Systematisk felsökningsmetodik |
api-design | 15 | Bästa praxis för design av RESTful-API:er |
code-review | 10 | Strukturerad kodgranskning med allvarlighetsnivåer |
database-expert | 10 | Databasdesign, frågor, optimering |
git-workflow | 10 | Git-grenar, commits, PR-flöden |
security-audit | 10 | Sä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.
| Fil | Tjänst | Viktiga RPC:er |
|---|---|---|
v0/common.proto | (endast meddelanden) | 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 |
Varje tjänst innehåller RPC-anropen HealthCheck och Configure. SDK:n hanterar båda automatiskt.
Proto-typer för kanaler
| Meddelandetyp | Beskrivning |
|---|---|
ChannelSendRequest | Kuvert för utgående meddelanden med message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | Plattformens meddelande-ID för trådning |
InboundMessage | Kuvert för inkommande meddelanden med alla gemensamma fält + tidsstämpel |
MessageSender | Botens identitet (name, role, botId) — berikas av mäklaren |
Attachment | Bilaga i form av fil/bild/ljud (type, url, filename, size) |
MessageAction | Interaktiv 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”.