NeboAI
NeboAI
はじめる

Nebo向けアプリを作る

AIに新しい力を。ツール、チャンネル、ゲートウェイ、UIパネルなど、思いつくものは何でも、ネイティブバイナリにコンパイルして実現できます。

概要

Neboとは

Neboは、デスクトップで使うパーソナルAIアシスタントです。常に稼働し、あなたのデジタルライフを管理するAI社員です。Neboはスマートフォンのようなものだと考えてください。強力なプラットフォームが、アプリによって大きく化けるのです。

Neboは単体でも、メモリ、スケジュール管理、Web閲覧、ファイル管理、シェルアクセスを備えた有能なAI社員です。ただし、本当の可能性を開くのはアプリです。スマートフォンの力がアプリのエコシステムから生まれるように、Neboの力も、できることを広げるアプリから生まれます。

アプリとは

Neboアプリは、驚くほどの機能を詰め込んだ、自己完結型のコンパイル済みユニットです。アプリごとにNeboに新しい力が加わります。カレンダー管理、メールの仕分け、プロジェクト管理、ホームオートメーション、財務分析など、開発者が思いつくものなら何でもです。

アプリは、非常に安全な方法で大きな力を提供します。すべてのアプリは、デフォルトで拒否する権限設定のサンドボックス内で動作します。アクセスできるのは、マニフェストで宣言され、ユーザーが承認したものだけです。

インターフェースは100%会話型です。ユーザーは、別の画面やダッシュボードを通じてアプリを操作しません。Neboに話しかけると、Neboがアプリのツールを使って仕事を片付けます。「明日の予定は?」と聞けば、Neboはカレンダーアプリを呼び出します。「午後3時にSarahとの会議を作って」と言えば、Neboはカレンダーアプリを呼び出します。ユーザーが会話から離れることはありません。

アプリは必要に応じて設定UIを提供できます。これはNebo内蔵のブラウザウィンドウで開く設定パネルで、ユーザーはここでAPIキーを入力したり、機能のオン・オフを切り替えたり、アプリを設定したりします。設定UIはマニフェストのsettings配列をもとに作られます(フォームはNeboが自動で描画します)。また、ui機能を使えば、アプリ独自のフルカスタムUIを提供することもできます。

アプリは、Neboの組み込み機能を置き換え、拡張します。Neboには基本的なプラットフォームツール(ローカルカレンダーへのアクセス、スクリーンショットなど)が付属しています。カレンダーアプリをインストールすると、組み込みのカレンダーツールが置き換わり、ローカル+クラウド+集約+空き状況の確認を備えた上位互換になります。

コンパイル済み限定ポリシー

Neboは、コンパイル済みバイナリのみを認める厳格なポリシーを採用しています。すべてのアプリは、ネイティブにコンパイルされた実行ファイルでなければなりません。

ステータス言語
対応Go(推奨)、Rust、C/C++、Zig
不可Python、Node.js、Ruby、Java、.NET、シェルスクリプト

理由:

  • AIによる自己改変の防止 — シェルアクセスを持つAI社員は、インタプリタ型スクリプトの動作を実行時に書き換えられてしまいます。コンパイル済みバイナリは、署名後は変更できません。
  • 署名の完全性 — Ed25519署名はバイナリの生のバイト列を対象とします。署名済みバイナリは、署名を無効にせずに変更することはできません。
  • サンドボックスの徹底 — バイナリ形式の検証(ELF/Mach-O/PEのマジックバイト)は、高速で確実な関門になります。

クイックスタート

SDKをインストール

公式SDKが、gRPCサーバーのセットアップ、シグナル処理、プロトコルのブリッジをすべて引き受けます。あなたはハンドラーのインターフェースを実装するだけです。

Go(推奨):

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

Rust(近日公開):

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

C/C++(近日公開):

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

アプリのディレクトリ構成

アプリは、Neboのデータディレクトリ内のapps/サブディレクトリに置きます:

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

最小構成のアプリのチェックリスト

  1. id、name、version、providesを含むmanifest.jsonを作成する
  2. AI社員がツールをどう使うべきかを説明するTOOL.mdを書く
  3. SDKをインストールする(go get github.com/neboloop/nebo-sdk-go)
  4. 機能に対応するハンドラーインターフェース(ToolHandler、ChannelHandlerなど)を実装する
  5. ハンドラーを登録し、app.Run()を呼び出す
  6. ネイティブバイナリをビルドする(go build -o binary .)
  7. バイナリ、manifest.json、TOOL.mdをapps/<your-app-id>/ディレクトリに置く
  8. Neboが自動で検出して起動します

設定

manifest.json

すべてのアプリには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
        }
    ]
}

必須フィールド:

フィールド説明
id逆ドメイン形式の識別子(例: com.mycompany.myapp)
name人が読める名前
versionセマンティックバージョンの文字列
provides1つ以上の機能(下記参照)

任意フィールド:

フィールドデフォルト説明
runtime"local""local"または"remote"
protocol"grpc""grpc"のみ対応
permissions[]アプリがアクセスを必要とするもの
description""UIに表示されます
settings[]設定可能な項目(設定UIに表示)
oauth[]OAuthプロバイダーの要件(下記のOAuthセクションを参照)

機能

アプリが提供するものを宣言します:

機能gRPCサービス説明
gatewayGatewayServiceLLMモデルのルーティング
tool:<name>ToolServiceAI社員が使う名前付きツール
channel:<name>ChannelServiceメッセージングチャンネル
commCommServiceAI社員同士のコミュニケーション
uiUIServiceHTTPプロキシ付きのカスタムUI
scheduleScheduleServiceカスタムスケジューリング
visionToolService画像処理
browserToolServiceブラウザの自動操作

1つのアプリで複数の機能を提供できます。たとえば、ツールとUIパネルの両方を提供するアプリも作れます。

権限

権限は、アプリがアクセスできるものを制御します。デフォルトは拒否で、宣言していないものはアプリから使えません。

プレフィックス例説明
network:network:outbound、network:*ネットワークへのアクセス
filesystem:filesystem:read、filesystem:writeファイルシステムへのアクセス
memory:memory:read、memory:writeAI社員のメモリへのアクセス
session:session:read会話セッション
tool:tool:shell、tool:file他のツールの使用
shell:shell:execシェルコマンドの実行
channel:channel:send、channel:*チャンネルの操作
comm:comm:send、comm:*AI社員同士の通信
model:model:chatAIモデルへのアクセス
user:user:tokenリクエストでユーザーのJWTを受け取る
schedule:schedule:createcronジョブの管理
database:database:queryデータベースへのアクセス
storage:storage:read、storage:write永続ストレージ
context:context:readAI社員のコンテキストへのアクセス
subagent:subagent:spawnサブエージェントの操作
lane:lane:enqueueレーンの操作
notification:notification:sendプッシュ通知
embedding:embedding:searchベクトル埋め込みへのアクセス
skill:skill:invokeスキルの呼び出し
advisor:advisor:consultアドバイザーシステムへのアクセス
mcp:mcp:connectMCPサーバーへのアクセス
voice:voice:record音声・オーディオへのアクセス
browser:browser:navigateブラウザの自動操作
oauth:oauth:google、oauth:*OAuthトークンへのアクセス
settings:settings:read設定へのアクセス
capability:capability:register機能の登録

ワイルドカード権限に対応しています。network:*は、あらゆるnetwork:権限のチェックに一致します。

設定

設定は、Nebo UIのアプリ設定パネルに表示されます。Neboは設定をデータベースに保存し、変更があるとConfigure RPCでアプリに送ります。

設定スキーマは、NeboAIアプリストアの掲載情報に含まれます。必須設定が未入力のアプリには、UIに「設定が必要」バッジが表示されます。

種類説明
text1行のテキスト入力
passwordマスク付きテキスト入力
toggleオン/オフの切り替えスイッチ
selectあらかじめ用意された選択肢のドロップダウン
number数値入力
url検証付きのURL入力
{
    "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の要件

アプリはOAuthプロバイダーの要件を宣言できます。フロー全体はNeboのOAuthブローカーが処理し、アプリはConfigure RPCを通じて自動でトークンを受け取ります。

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
フィールド説明
providerOAuthプロバイダー: "google"、"microsoft"、"github"
scopesアプリが必要とするOAuthスコープの配列

ユーザーがアプリをインストールすると、Neboが必要なOAuthスコープの承認を求めます。アプリ自身がOAuthフローを処理しなくても、更新されたトークンをConfigure RPCで受け取れます。

環境変数

アプリのプロセスには、無害化された環境が渡されます。シークレットはすべて取り除かれます。渡されるのは次のとおりです:

変数値
NEBO_APP_DIRアプリのインストールディレクトリ
NEBO_APP_SOCK作成するUnixソケットのパス
NEBO_APP_IDマニフェストのアプリID
NEBO_APP_NAMEマニフェストのアプリ名
NEBO_APP_VERSIONマニフェストのアプリのバージョン
NEBO_APP_DATAアプリのdata/ディレクトリのパス
PATHシステムのPATH(そのまま引き継ぎ)
HOMEユーザーのホームディレクトリ(そのまま引き継ぎ)
TMPDIR一時ディレクトリ(そのまま引き継ぎ)

重要:バイナリは、NEBO_APP_SOCKのUnixソケットで待ち受けるgRPCサーバーを作成する必要があります。Neboはこのソケットが現れるまで最大10秒待ちます。

アプリの起動シーケンス

  1. Neboがmanifest.jsonを読み込み、検証する
  2. アプリディレクトリ内の実行ファイルbinaryまたはappを見つける
  3. .quarantinedマーカーを確認する(隔離されたアプリは起動を拒否)
  4. 失効の確認(NeboAIで配布されたアプリのみ)
  5. 署名の検証(NeboAIで配布されたアプリのみ。開発時はスキップ)
  6. バイナリの検証(シンボリックリンク、スクリプト、実行できないファイル、サイズ超過のファイルは拒否)
  7. 前回の実行で残った古いソケットを削除する
  8. サンドボックス化されたストレージ用にdata/ディレクトリを作成する
  9. アプリごとのログファイル(logs/stdout.log、logs/stderr.log)を用意する
  10. 無害化された環境とプロセスグループの分離のもとでバイナリを起動する
  11. Unixソケットが現れるのを待つ(指数バックオフ、最大10秒)
  12. Unixソケット経由でgRPC接続する
  13. providesに応じて、機能ごとのgRPCクライアントを作成する
  14. ヘルスチェックを実行する
  15. 機能(ツール、ゲートウェイ、通信など)をAI社員に登録する

ツールアプリ

マニフェストで"provides": ["tool:my_tool_name"]を宣言します。

STRAPパターン

Neboのツールアプリはすべて、スキーマと実行のルーティングにSTRAP(Single Tool Resource Action Pattern)を必ず使用してください。これはNeboが内部で35以上の個別ツールを4つのドメインツールにまとめるのに使っているパターンと同じもので、LLMのコンテキスト負荷を約80%削減します。

基本の考え方:複数のツール(get_events、check_availability、suggest_slots)を登録する代わりに、action(必要に応じてresource)フィールドを持つツールを1つだけ登録し、適切なハンドラーに振り分けます。

単一リソースの例(カレンダー):

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

複数リソースの例(プロジェクト管理):

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

スキーマのルール:

  1. 必須の文字列enumとして、actionフィールドを必ず含める
  2. resourceフィールド(必須の文字列enum)は、ツールが複数の異なるリソースの種類を扱う場合にのみ追加する
  3. それ以外のフィールドはすべて、アクションごとのパラメーター
  4. action enumの説明には、使用できるアクションをすべて列挙する

STRAPが重要な理由:

  • LLMはactionによるルーティングのパターンを一度覚えれば、あらゆる操作に応用できる
  • ツール定義はコンテキストの約6%を占めるが、STRAPならそれを80%削減できる
  • 新しい操作はenumに追加するだけで、新しいツールを登録する必要はない
  • ホスト型モデルでもローカルモデルでも同じように動く

Goの例 — 電卓ツール

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

ビルドとインストール:

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の例

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の例

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

チャンネルアプリ

"provides": ["channel:my_channel"]と"permissions": ["channel:send"]を宣言します。

チャンネルアプリは、外部のメッセージングプラットフォーム(Telegram、Discord、Slackなど)とNeboのAI社員をつなぎます。ユーザーが外部プラットフォームでメッセージを送ると、アプリがReceiveでNeboにストリーミングします。AI社員が返信するときは、NeboがアプリのSendを呼び出します。

仕組み

  1. NeboがID()を呼び出し、チャンネルの一意な識別子を取得する
  2. Neboが、アプリの設定から得た構成でConnect()を呼び出す
  3. NeboがReceive()ストリームを開く。ユーザーがボットにメッセージを送るたびに、アプリが受信メッセージを送る
  4. 受信メッセージは、AI社員のメインの会話レーンに振り分けられる
  5. AI社員がメッセージを送るとき、Neboがv1メッセージエンベロープを付けてSend()を呼び出す
  6. 終了時に、NeboがDisconnect()を呼び出す

v1メッセージエンベロープ

チャンネルのメッセージはすべて、受信・送信を問わず共通のメッセージエンベロープを使います:

{
  "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"
}
フィールド種類説明
message_idUUID v7時系列順の一意なID
channel_id{type}:{platform_id}ルーティング可能なチャンネル識別子
senderobjectボットの身元 — 名前、役割、botId
textstringメッセージ本文
attachmentsarrayファイル、画像、音声
reply_toUUID v7スレッド表示のための親メッセージID
actionsarrayインタラクティブなボタン・キーボード
platform_databytesプラットフォーム固有の機能のための不透明なパススルー
timestampISO 8601パブリッシャーが設定

2層の設計:共通フィールド(テキスト、添付ファイル、reply_to、アクション)で、社員から始まるメッセージのやり取りの90%をカバーします。プラットフォーム固有の機能はplatform_dataに入れ、プラグインがネイティブのプラットフォーム形式との間で変換します。

会話ストリーム

チャンネルのメッセージは、分離のためにチャンネルごとの会話ストリームで振り分けられます:

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

Goの例 — Telegramチャンネル

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

その他の機能

通信アプリ

"provides": ["comm"]と"permissions": ["comm:*"]を宣言します。通信アプリは、AI社員同士のコミュニケーションを可能にします。

フィールド説明
from送信元の社員ID
to送信先の社員ID
topicメッセージのトピック・チャンネル
type"message"、"mention"、"proposal"、"command"、"info"、"task"
contentメッセージ本文

主な動作:

  • Registerは、このAI社員とその機能をネットワークに告知します
  • Subscribe/Unsubscribeはトピックの購読を管理します
  • Receiveは受信メッセージをストリーミングします(サーバーストリーミング、チャンネルと同じ)
  • 一度に有効にできる通信アプリは1つだけです

ゲートウェイアプリ

ゲートウェイアプリは、LLMへのリクエストをモデルに振り分けます。"provides": ["gateway"]と"permissions": ["network:outbound", "user:token"]を宣言します。

GatewayRequestには、メッセージ、ツール、システムプロンプト、最大トークン数、temperature、そしてUserContext(user:token権限が付与されている場合はJWTトークン)が含まれます。

GatewayEventの種類:

種類内容説明
"text"テキストのチャンクストリーミングされるテキストトークン
"tool_call"JSONモデルがツールの呼び出しを求めている
"thinking"テキストのチャンク拡張思考・推論
"error"エラーメッセージ問題が発生した
"done"空ストリームが完了した

UIアプリ

UIアプリは、Nebo内蔵のブラウザウィンドウで開く独自の設定画面を提供します。"provides": ["ui"]を宣言します。(マニフェストのsettingsからNeboが描画する)自動の設定フォームとは違い、UIアプリは独自のHTML/CSS/JSフロントエンド一式を配信します。

アプリには、静的なWebアセット(HTML、CSS、JS。通常はindex.htmlを持つSPA)を収めたui/ディレクトリを同梱します。Neboはこれらのファイルを直接配信し、APIの呼び出しをgRPC経由でアプリにプロキシします。

パス仕組み目的
GET /api/v1/apps/{id}/ui/*静的ファイルサーバーui/ディレクトリのファイルを配信します(SPAのフォールバック先はindex.html)
ANY /api/v1/apps/{id}/api/*gRPCプロキシHTTPリクエストをアプリのUIService.HandleRequest()にプロキシします

SDKは標準のnet/http.ServeMuxをラップしているので、普段どおりのGoのHTTPハンドラーを書くだけです。gRPCのブリッジはSDKが自動で処理します。

Goの例 — ダッシュボードUI:

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())
}

ui/index.htmlから/api/v1/apps/com.example.dashboard/api/statusにfetchを呼び出すと、その呼び出しがmuxハンドラーへプロキシされます。

スケジュールアプリ

スケジュールアプリは、Nebo組み込みのcronスケジューラーを置き換えます。"provides": ["schedule"]と"permissions": ["schedule:create"]を宣言します。

スケジュールアプリが起動すると、Neboはデフォルトのcronエンジンではなく、そのアプリを通してすべてのスケジュールを処理します。アプリがクラッシュした場合、Neboは自動的に組み込みエンジンに切り替えます。

  • アプリがスケジュールの状態を所有します。スケジュールアプリが有効な間、Neboは自身のDBにスケジュールを保存しません
  • 標準的なCRUD: Create、Get、List、Update、Delete、Enable、Disable
  • TriggersはサーバーストリーミングRPCです。スケジュールが発火するたびに、アプリがトリガーメッセージを送ります
  • 一度に有効にできるスケジュールアプリは1つだけです

複数機能のアプリ

1つのアプリで複数の機能を提供できます。たとえば、ツールとUIの両方を持つダッシュボードアプリです:

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

パッケージング

.napp形式

NeboAIで配布するには、アプリを.nappファイル(tar.gzアーカイブ)としてパッケージします:

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

必須ファイル:

ファイル最大サイズ説明
manifest.json1 MBアプリのメタデータ
binaryまたはapp500 MB実行ファイル
signatures.json1 MBEd25519署名
TOOL.md1 MBAI社員向けのツールの説明

展開時のセキュリティルール:

  • パストラバーサル不可(../は拒否)
  • シンボリックリンク不可(拒否)
  • 絶対パス不可(拒否)
  • 許可リストにあるファイル名のみ受け付け

署名

NeboAIはEd25519でアプリに署名します。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>"
}

開発モード(NeboAIのURLが未設定)では、署名の検証は完全にスキップされます。ローカル開発にはsignatures.jsonは不要です。

公開

アプリがローカルで動いたら、NeboAIで公開して、すべてのNeboユーザーに配布しましょう。

開発者アカウントのセットアップ

  1. POST /api/v1/owners/registerでNeboAIアカウントを登録する
  2. ログインしてJWTトークンを取得する: POST /api/v1/owners/login
  3. 開発者アカウントを作成する: POST /api/v1/developer/accounts

申請の流れ

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

ステップ1: アプリを作成する

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"
  }'

ステップ2: プラットフォームごとのバイナリをアップロードする

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"

プラットフォームごとにバイナリを1つずつアップロードします: darwin-arm64、darwin-amd64、linux-amd64、linux-arm64。

ステップ3: 審査に申請する

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

審査の流れ

  1. 自動スキャン — バイナリはVirusTotalでスキャンされます
  2. 管理者による審査 — NeboAIチームがメタデータ、マニフェスト、スキャン結果を確認します
  3. 承認された場合 — NeboAIがEd25519でアプリに署名し、公開します
  4. 却下された場合 — 理由が届くので、修正して再申請できます

目標審査時間: 24時間未満。

アップデートの配信

  1. アプリのバージョンを更新する:新しいバージョンを指定して PUT /api/v1/developer/apps/{id}
  2. プラットフォームごとに新しいバイナリをアップロードする
  3. もう一度審査に申請する

アップデートはすべて同じ審査を通ります。新しいバージョンが承認されるまで、以前のバージョンは引き続き利用できます。

ストアのメタデータ

フィールド説明
category例: productivity、communication、developer-tools
iconアプリアイコンのURL
visibilitypublicまたはprivate
descriptionマニフェストの説明より長く、詳しく書けます

開発ワークフロー

ローカル開発

ローカル開発ではパッケージングは不要です:

  1. アプリのディレクトリを作成します:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. manifest.jsonとコードを書く
  3. バイナリをビルドします:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Neboが新しいディレクトリを自動で検出します(またはNeboを再起動します)
  5. コードを変更したらバイナリを再ビルドします。ファイルウォッチャーがアプリを再起動します

ログの確認

アプリのstdout/stderrは、アプリごとのログファイルに記録されます:

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

永続データ

アプリが保持する必要のあるファイルには、data/ディレクトリ(環境変数NEBO_APP_DATAでも参照可能)を使います。このディレクトリは、アプリのアップデートや隔離の後も残ります。

デバッグのヒント

  • アプリが起動しない場合は、logs/stderr.logでエラーを確認する
  • バイナリが実行可能になっているか確認する(chmod +x binary)
  • NEBO_APP_SOCKのUnixソケットパスで待ち受けているか確認する
  • ソケットは起動から10秒以内に準備できている必要があります
  • ストレージには、ハードコードしたパスではなくNEBO_APP_DATAを使う
  • デバッグログはstderrに出力する(logs/stderr.logに記録されます)

確認

# 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

アンインストール

nebo apps uninstall com.example.myapp

スキル

スキルとは

スキルは、会話中のNeboのふるまいを形づくる指示のセットです。スキルが有効になると、その内容がシステムプロンプトに直接挿入され、そのセッションでのAI社員の口調、進め方、専門知識、ツールの使い方を導きます。

スキルはコードではありません。YAMLメタデータ付きのMarkdown文書です。コンパイルもバイナリもgRPCも不要です。スキルとは、ディレクトリ内のSKILL.mdファイル1つだけ。それだけです。

スキルは状況に応じた一時的なものです。関係があるとき(トリガーの一致または手動の読み込み)に有効になり、数ターンの間続き、不要になると期限切れになります。これによりAI社員のコンテキストが軽く保たれ、プロンプトには今必要な指示だけが入ります。

スキルはアプリを補完します。アプリは実行可能な機能(ツール、チャンネル、ゲートウェイ)を提供します。スキルは、そのツールをうまく使うための段取りの指示を提供します。カレンダーアプリはNeboに予定を読み書きする力を与えます。「会議の準備」スキルは、そのカレンダーアプリ、メール、Web検索を組み合わせてどう会議の準備をするかをNeboに教えます。

スキルとアプリの違い

スキルアプリ
形式Markdown(SKILL.md)コンパイル済みバイナリ(.napp)
実行方式システムプロンプトに挿入gRPCで通信するサンドボックス化されたプロセス
提供するものふるまいの指針、進め方ツール、チャンネル、UIパネル
存続期間セッション単位、TTLで期限切れ常に稼働
作成方法Markdownファイルを書く書く、コンパイルする、署名する、パッケージする
セキュリティ権限は不要デフォルト拒否のサンドボックス

クイックスタート

Neboのskillsフォルダにディレクトリを作り、SKILL.mdファイルを置きます:

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

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はfsnotifyでskillsディレクトリを監視しています。スキルはすぐに使えるようになり、再起動は不要です。トリガーに一致することを話しかければ、自動で有効になります。

または、Neboに直接頼むこともできます。「ブログ記事を書くためのスキルを作って」と言えば、NeboがSKILL.mdファイルを書いてくれます。

SKILL.mdの形式

スキルはそれぞれ1つのSKILL.mdファイルで、2つの部分からなります。---マーカーで囲まれたYAMLフロントマターと、Markdownの本文(システムプロンプトに実際に挿入される指示)です。

フィールド必須デフォルト説明
nameはい—一意な識別子(スラッグになります)
descriptionはい—スキルカタログに表示される1行の説明
versionいいえ"1.0.0"更新を追跡するためのセマンティックバージョン
authorいいえ—スキルの作成者
priorityいいえ0大きいほど先に一致(重要な上書きには100以上)
max_turnsいいえ4自動で期限切れになるまでの無操作ターン数
triggersいいえ[]このスキルを自動で有効にするフレーズ(大文字小文字を区別しない部分一致)
toolsいいえ[]このスキルが使う想定のツール(参考情報)
dependenciesいいえ[]インストールが必要な他のスキル
tagsいいえ[]分類と発見のため
platformいいえ[]対応プラットフォーム: macos、linux、windows(空欄ならすべて)

スキルが有効になる仕組み

スキルは2段階の有効化モデルに従います。ヒント、そして呼び出しです。

フェーズ1: トリガーの照合 — ユーザーがメッセージを送るたびに、Neboは登録済みのすべてのスキルについてトリガーの一致を調べます。一致したスキルは、システムプロンプトにヒントとして表示されます。AI社員はヒントを見て、スキルを呼び出すかどうかを判断します。

フェーズ2: 呼び出し — AI社員は、次を呼び出してスキルを起動します:

skill(name: "code-review")

これにより、SKILL.mdのテンプレート全体がツールの結果として返され、呼び出しが記録され、以降のターンでもテンプレートがシステムプロンプトに再挿入されます。

TTLと期限切れ:

  • 自動で一致したスキル: 無操作4ターン(max_turnsで変更可能)
  • 手動で読み込んだスキル: 無操作6ターン
  • もう一度呼び出すとタイマーがリセットされます
  • 上限: 1セッションにつき有効なスキルは最大4つ
  • トークン予算: 有効なスキルの内容は合計16,000文字まで

スキルの管理

AI社員はskillツールでスキルを管理できます:

アクション説明例
catalog使用できるすべてのスキルを一覧表示skill(action: "catalog")
loadこのセッションで有効にするskill(name: "code-review", action: "load")
unloadスキルを無効にするskill(name: "code-review", action: "unload")
createディスク上に新しいスキルを作成skill(action: "create", content: "...")
update既存のスキルを更新skill(name: "my-skill", action: "update", content: "...")
deleteディスクからスキルを削除skill(name: "my-skill", action: "delete")

よいスキルの書き方

よいスキルのテンプレートには、次のものがあります:

  1. わかりやすい見出し — AI社員に今どのモードなのかを伝えます
  2. 基本原則 — 譲れないふるまいのルール
  3. 進め方 — よくある場面での手順
  4. 例 — ユーザーのメッセージと応答の具体的なパターン
  5. アンチパターン — やってはいけないこと(モデルは悪い例からよく学びます)

ヒント:1つのスキルは1つのことをうまくこなすべきです。「プログラミング全般」のスキルは作らず、code-review、debugging、api-designを別々のスキルとして作りましょう。AI社員は複数のスキルを同時に有効にできます。

同梱スキル

Neboには、よくある用途をカバーするスキルが同梱されています:

スキル優先度説明
onboarding100新規ユーザーへのあいさつとプロフィールの収集
best-friend50性格スキル — 気さくで誠実、本音で話す
debugging25体系的なデバッグの進め方
api-design15RESTful API設計のベストプラクティス
code-review10重大度レベル付きの構造化されたコードレビュー
database-expert10データベースの設計、クエリ、最適化
git-workflow10Gitのブランチ、コミット、PRのワークフロー
security-audit10セキュリティ分析と脆弱性の検出

これらは便利なデフォルトであると同時に、自分のスキルを作るときの参考実装にもなります。

リファレンス

Protoファイル

Protoファイルはproto/apps/v0/にあります。SDKには生成済みのコードが含まれているので、通常の開発ではprotocは不要です。

ファイルサービス主なRPC
v0/common.proto(メッセージのみ)HealthCheckRequest/Response、SettingsMap、UserContext、Empty
v0/tool.protoToolServiceName、Description、Schema、Execute、RequiresApproval、Configure
v0/channel.protoChannelServiceID、Connect、Disconnect、Send、Receive(ストリーム)、Configure
v0/comm.protoCommServiceName、Version、Connect、Disconnect、Send、Subscribe、Register、Receive(ストリーム)、Configure
v0/gateway.protoGatewayServiceHealthCheck、Stream(ストリーム)、Poll、Cancel、Configure
v0/ui.protoUIServiceHealthCheck、HandleRequest、Configure
v0/schedule.protoScheduleServiceHealthCheck、Create、Get、List、Update、Delete、Enable、Disable、Trigger、History、Triggers(ストリーム)、Configure

どのサービスにもHealthCheckとConfigureのRPCがあります。どちらもSDKが自動で処理します。

チャンネルのProto型

メッセージ型説明
ChannelSendRequestmessage_id、channelId、sender、text、attachments、reply_to、actions、platform_dataを含む送信メッセージのエンベロープ
ChannelSendResponseスレッド表示のためのプラットフォームのメッセージID
InboundMessage共通フィールドすべてとタイムスタンプを含む受信メッセージのエンベロープ
MessageSenderボットの身元(name、role、botId) — ブローカーが情報を付加
Attachmentファイル・画像・音声の添付(type、url、filename、size)
MessageActionインタラクティブなボタン・キーボードのアクション(label、callback_id)

ボットの身元と役割

Neboのボットには、3つの軸からなる身元モデルがあります:

  • creature — ボットが何者か(原型):「機転の利く戦略家」「几帳面なリサーチャー」
  • role — ユーザーとどんな関係か(関係性):「友人」「COO」「メンター」
  • vibe — どんな雰囲気か(話し方のスタイル):「のんびりだけど意見ははっきり」「温かく励ましてくれる」

チャンネルプラグインが送信メッセージを受け取ると、senderフィールドにボットのnameとroleが入っています。これを使って、プラットフォーム向けの表示名を整えてください。roleは肩書きではなく、関係性を表すものです。「COO」や「DevLead」と並んで、「友人」「息子」「メンター」も有効なroleです。