NeboAI
NeboAI
Aloita

Rakenna sovelluksia Nebolle

Anna tekoälyllesi uusia supervoimia. Työkalut, kanavat, yhdyskäytävät, käyttöliittymäpaneelit — mitä ikinä keksit, käännettynä natiiviksi binääriksi.

Yleiskatsaus

Mikä Nebo on

Nebo on henkilökohtainen työpöydän tekoälyavustaja — aina käynnissä oleva tekoälytyöntekijä, joka hoitaa digitaalista elämääsi. Ajattele Neboa samoin kuin älypuhelinta: tehokas alusta, josta tulee mullistava sovellustensa ansiosta.

Sellaisenaan Nebo on kyvykäs tekoälytyöntekijä, jolla on muisti, ajastus, verkkoselaus, tiedostojen hallinta ja komentotulkin käyttö. Todellinen avain ovat kuitenkin sovellukset. Aivan kuten älypuhelimen voima tulee sen sovellusekosysteemistä, Nebon voima tulee sovelluksista, jotka laajentavat sen kykyjä.

Mitä sovellukset ovat

Nebo-sovellukset ovat itsenäisiä, valmiiksi käännettyjä ja uskomattoman toimivia kokonaisuuksia. Jokainen sovellus antaa Nebolle uuden supervoiman — kalenterin hallinta, sähköpostien lajittelu, projektien seuranta, kodin automaatio, talousanalyysi — mitä tahansa kehittäjä keksii.

Sovellukset tarjoavat uskomatonta tehoa erittäin turvallisella tavalla. Jokainen sovellus toimii hiekkalaatikossa, jossa kaikki on oletuksena kielletty. Se pääsee käsiksi vain siihen, minkä sen manifesti ilmoittaa ja käyttäjä hyväksyy.

Käyttöliittymä on 100-prosenttisesti keskusteleva. Käyttäjät eivät käytä sovelluksia erillisten näkymien tai koontinäyttöjen kautta. He puhuvat Nebolle, ja Nebo käyttää sovelluksen työkaluja asioiden hoitamiseen. ”Mitä kalenterissani on huomenna?” — Nebo kutsuu kalenterisovellusta. ”Luo tapaaminen Sarahin kanssa kello 15” — Nebo kutsuu kalenterisovellusta. Käyttäjä ei koskaan poistu keskustelusta.

Sovellukset voivat halutessaan tarjota asetusnäkymän — määrityspaneelin, joka avautuu Nebon sisäänrakennettuun selainikkunaan. Siellä käyttäjät syöttävät API-avaimia, kytkevät ominaisuuksia päälle ja pois ja määrittävät sovelluksen. Asetusnäkymää ohjaa manifestin settings-taulukko (Nebo piirtää lomakkeen automaattisesti), tai sovellus voi tarjota oman täysin mukautetun käyttöliittymän ui-kyvyn kautta.

Sovellukset korvaavat ja laajentavat Nebon sisäänrakennettuja kykyjä. Nebon mukana tulee perustason alustatyökaluja (paikallisen kalenterin käyttö, kuvakaappaukset jne.). Kun asennat kalenterisovelluksen, se korvaa sisäänrakennetun kalenterityökalun ja muodostaa sen ylijoukon — paikallinen + pilvi + yhdistäminen + saatavuuden tarkistus.

Vain käännetyt -käytäntö

Nebo noudattaa tiukkaa käytäntöä, jonka mukaan vain käännetyt binäärit sallitaan. Kaikkien sovellusten on oltava natiivisti käännettyjä suoritettavia tiedostoja.

TilaKielet
TuettuGo (suositeltu), Rust, C/C++, Zig
HylättyPython, Node.js, Ruby, Java, .NET, komentotulkin skriptit

Perustelut:

  • Tekoälyn itsemuokkauksen estäminen — Tekoälytyöntekijä, jolla on komentotulkin käyttöoikeus, voisi muuttaa tulkattavan skriptin toimintaa ajon aikana. Käännetyt binäärit ovat muuttumattomia allekirjoittamisen jälkeen.
  • Allekirjoituksen eheys — Ed25519-allekirjoitukset kattavat binäärin raakatavut. Allekirjoitettua binääriä ei voi muokata mitätöimättä allekirjoitusta.
  • Hiekkalaatikon valvonta — Binäärimuodon validointi (ELF/Mach-O/PE-tunnistetavut) on nopea ja luotettava portti.

Pika-aloitus

Asenna SDK

Viralliset SDK:t hoitavat kaiken gRPC-palvelimen käyttöönoton, signaalien käsittelyn ja protokollasiltauksen. Sinä vain toteutat käsittelijärajapinnat.

Go (suositeltu):

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

Rust (tulossa pian):

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

C/C++ (tulossa pian):

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

Sovelluksen hakemistorakenne

Sovellukset sijaitsevat Nebon datahakemiston alihakemistossa 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)

Minimisovelluksen tarkistuslista

  1. Luo manifest.json, jossa on id, name, version, provides
  2. Kirjoita TOOL.md, joka kuvaa, miten tekoälytyöntekijän tulee käyttää työkaluasi
  3. Asenna SDK (go get github.com/neboloop/nebo-sdk-go)
  4. Toteuta kykysi käsittelijärajapinta (ToolHandler, ChannelHandler jne.)
  5. Rekisteröi käsittelijä ja kutsu app.Run()
  6. Rakenna natiivi binääri (go build -o binary .)
  7. Sijoita binääri + manifest.json + TOOL.md hakemistoon apps/<your-app-id>/
  8. Nebo löytää ja käynnistää sen automaattisesti

Määritykset

manifest.json

Jokainen sovellus vaatii tiedoston 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
        }
    ]
}

Pakolliset kentät:

KenttäKuvaus
idKäänteisen verkkotunnuksen muotoinen tunniste (esim. com.mycompany.myapp)
nameIhmisluettava nimi
versionSemver-merkkijono
providesVähintään yksi kyky (katso alla)

Valinnaiset kentät:

KenttäOletusKuvaus
runtime"local""local" tai "remote"
protocol"grpc"Vain "grpc" on tuettu
permissions[]Mihin sovellus tarvitsee käyttöoikeuden
description""Näytetään käyttöliittymässä
settings[]Määritettävät asetukset (näytetään asetusnäkymässä)
oauth[]OAuth-palveluntarjoajan vaatimukset (katso OAuth-osio alla)

Kyvyt

Ilmoita, mitä sovelluksesi tarjoaa:

KykygRPC-palveluKuvaus
gatewayGatewayServiceLLM-mallien reititys
tool:<name>ToolServiceNimetty työkalu tekoälytyöntekijälle
channel:<name>ChannelServiceViestikanava
commCommServiceViestintä tekoälytyöntekijöiden välillä
uiUIServiceMukautettu käyttöliittymä HTTP-välityspalvelimella
scheduleScheduleServiceMukautettu ajastus
visionToolServiceKuvien käsittely
browserToolServiceSelainautomaatio

Sovellus voi tarjota useita kykyjä. Sovellus voi esimerkiksi tarjota sekä työkalun että käyttöliittymäpaneelin.

Luvat

Luvat määräävät, mihin sovellus pääsee käsiksi. Oletuksena kielletty — jos lupaa ei ole ilmoitettu, sovellus ei voi käyttää sitä.

EtuliiteEsimerkitKuvaus
network:network:outbound, network:*Verkkoyhteys
filesystem:filesystem:read, filesystem:writeTiedostojärjestelmän käyttö
memory:memory:read, memory:writeTekoälytyöntekijän muistin käyttö
session:session:readKeskusteluistunnot
tool:tool:shell, tool:fileMuiden työkalujen käyttö
shell:shell:execKomentotulkin komentojen suoritus
channel:channel:send, channel:*Kanavatoiminnot
comm:comm:send, comm:*Viestintä tekoälytyöntekijöiden välillä
model:model:chatTekoälymallien käyttö
user:user:tokenKäyttäjän JWT:n vastaanotto pyynnöissä
schedule:schedule:createCron-töiden hallinta
database:database:queryTietokannan käyttö
storage:storage:read, storage:writePysyvä tallennus
context:context:readTekoälytyöntekijän kontekstin käyttö
subagent:subagent:spawnAla-agenttien toiminnot
lane:lane:enqueueKaistatoiminnot
notification:notification:sendPush-ilmoitukset
embedding:embedding:searchVektoriupotusten käyttö
skill:skill:invokeTaitojen kutsuminen
advisor:advisor:consultNeuvonantajajärjestelmän käyttö
mcp:mcp:connectMCP-palvelimen käyttö
voice:voice:recordÄänen/audion käyttö
browser:browser:navigateSelainautomaatio
oauth:oauth:google, oauth:*OAuth-tunnusten käyttö
settings:settings:readAsetusten käyttö
capability:capability:registerKykyjen rekisteröinti

Jokerimerkkiluvat ovat tuettuja: network:* vastaa mitä tahansa network:-lupatarkistusta.

Asetukset

Asetukset näkyvät Nebon käyttöliittymässä sovelluksen asetuspaneelissa. Nebo tallentaa ne tietokantaan ja lähettää ne sovelluksellesi Configure-RPC:n kautta, kun ne muuttuvat.

Asetusskeemasi sisältyy NeboAI-sovelluskaupan listaukseen. Sovellukset, joiden pakollisia asetuksia ei ole määritetty, näyttävät käyttöliittymässä ”Needs Setup” -merkin.

TyyppiKuvaus
textYksirivinen tekstikenttä
passwordPeitetty tekstikenttä
toggleTotuusarvoinen päälle/pois-kytkin
selectPudotusvalikko ennalta määritetyillä vaihtoehdoilla
numberNumerokenttä
urlURL-kenttä validoinnilla
{
    "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-vaatimukset

Sovellukset voivat ilmoittaa OAuth-palveluntarjoajan vaatimuksia. Nebon OAuth-välittäjä hoitaa koko prosessin — sovellukset saavat tunnukset automaattisesti Configure-RPC:n kautta.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
KenttäKuvaus
providerOAuth-palveluntarjoaja: "google", "microsoft", "github"
scopesTaulukko sovelluksen tarvitsemista OAuth-laajuuksista

Kun käyttäjä asentaa sovelluksen, Nebo pyytää häntä valtuuttamaan vaaditut OAuth-laajuudet. Sovellus saa päivitetyt tunnukset Configure-RPC:n kautta ilman, että sen tarvitsee itse hoitaa OAuth-prosessia.

Ympäristömuuttujat

Sovellusprosessisi saa puhdistetun ympäristön. Kaikki salaisuudet poistetaan. Saat:

MuuttujaArvo
NEBO_APP_DIRSovelluksen asennushakemisto
NEBO_APP_SOCKLuotavan Unix-socketin polku
NEBO_APP_IDSovelluksen ID manifestista
NEBO_APP_NAMESovelluksen nimi manifestista
NEBO_APP_VERSIONSovelluksen versio manifestista
NEBO_APP_DATAPolku sovelluksen data/-hakemistoon
PATHJärjestelmän PATH (välitetään sellaisenaan)
HOMEKäyttäjän kotihakemisto (välitetään sellaisenaan)
TMPDIRVäliaikaishakemisto (välitetään sellaisenaan)

Tärkeää: Binäärisi on luotava gRPC-palvelin, joka kuuntelee Unix-socketia polussa NEBO_APP_SOCK. Nebo odottaa tämän socketin ilmestymistä enintään 10 sekuntia.

Sovelluksen käynnistysjärjestys

  1. Nebo lukee tiedoston manifest.json ja validoi sen
  2. Etsii sovellushakemistosta suoritettavan tiedoston binary tai app
  3. Tarkistaa .quarantined-merkinnän (karanteeniin asetettuja sovelluksia ei käynnistetä)
  4. Mitätöintitarkistus (vain NeboAI:n jakelemat sovellukset)
  5. Allekirjoituksen vahvistus (vain NeboAI:n jakelemat sovellukset, ohitetaan kehitystilassa)
  6. Binäärin validointi (hylkää symboliset linkit, skriptit, ei-suoritettavat ja liian suuret tiedostot)
  7. Siivoaa edellisen ajon vanhentuneen socketin
  8. Luo data/-hakemiston hiekkalaatikoitua tallennusta varten
  9. Määrittää sovelluskohtaiset lokitiedostot (logs/stdout.log, logs/stderr.log)
  10. Käynnistää binäärin puhdistetulla ympäristöllä ja prosessiryhmän eristyksellä
  11. Odottaa Unix-socketin ilmestymistä (eksponentiaalinen viive, enintään 10 sekuntia)
  12. Yhdistää gRPC:llä Unix-socketin kautta
  13. Luo kykykohtaiset gRPC-asiakkaat provides-kentän perusteella
  14. Suorittaa kuntotarkistuksen
  15. Rekisteröi kyvyt tekoälytyöntekijälle (työkalut, yhdyskäytävä, viestintä jne.)

Työkalusovellukset

Ilmoita manifestissasi "provides": ["tool:my_tool_name"].

STRAP-malli

Kaikkien Nebon työkalusovellusten on käytettävä STRAP-mallia (Single Tool Resource Action Pattern) skeemassaan ja suorituksen reitityksessä. Tämä on sama malli, jolla Nebo sisäisesti yhdistää yli 35 yksittäistä työkalua 4 aluekohtaiseksi työkaluksi — mikä vähentää LLM:n kontekstikuormaa noin 80 %.

Perusajatus: Sen sijaan, että rekisteröisit useita työkaluja (get_events, check_availability, suggest_slots), rekisteröi YKSI työkalu, jossa on action-kenttä (ja valinnaisesti resource-kenttä), jotka reitittävät oikealle käsittelijälle.

Yhden resurssin esimerkki (kalenteri):

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

Usean resurssin esimerkki (projektinhallinta):

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

Skeemasäännöt:

  1. Sisällytä aina action-kenttä pakollisena merkkijonoenumina
  2. Lisää resource-kenttä (pakollinen merkkijonoenum) vain, jos työkalusi hallitsee useita erillisiä resurssityyppejä
  3. Kaikki muut kentät ovat toimintokohtaisia parametreja
  4. action-enumin kuvauksessa tulee luetella kaikki käytettävissä olevat toiminnot

Miksi STRAP on tärkeä:

  • LLM:t oppivat action-reitityksen mallin kerran ja yleistävät sen kaikkiin toimintoihin
  • Työkalumääritykset vievät noin 6 % kontekstista — STRAP leikkaa sitä 80 %
  • Uudet toiminnot ovat vain enum-lisäyksiä, eivät uusia työkalurekisteröintejä
  • Toimii samalla tavalla sekä isännöidyillä että paikallisilla malleilla

Go-esimerkki — laskintyökalu

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

Rakenna ja asenna:

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

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

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

Kanavasovellukset

Ilmoita "provides": ["channel:my_channel"] ja "permissions": ["channel:send"].

Kanavasovellukset yhdistävät ulkoiset viestialustat (Telegram, Discord, Slack jne.) Nebon tekoälytyöntekijään. Kun käyttäjä lähettää viestin ulkoisella alustalla, sovelluksesi suoratoistaa sen Nebolle Receive-kutsun kautta. Kun tekoälytyöntekijä haluaa vastata, Nebo kutsuu sovelluksesi Send-metodia.

Näin se toimii

  1. Nebo kutsuu ID()-metodia saadakseen kanavasi yksilöllisen tunnisteen
  2. Nebo kutsuu Connect()-metodia sovelluksesi asetuksista saaduilla määrityksillä
  3. Nebo avaa Receive()-virran — sovelluksesi lähettää saapuvat viestit aina, kun käyttäjä lähettää botille viestin
  4. Saapuvat viestit reititetään tekoälytyöntekijän pääkeskustelukaistalle
  5. Kun tekoälytyöntekijä haluaa lähettää viestin, Nebo kutsuu Send()-metodia v1-viestikuorella
  6. Sammutettaessa Nebo kutsuu Disconnect()-metodia

v1-viestikuori

Kaikki kanavaviestit — saapuvat ja lähtevät — käyttävät yhteistä viestikuorta:

{
  "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"
}
KenttäTyyppiKuvaus
message_idUUID v7Aikajärjestetty yksilöllinen ID
channel_id{type}:{platform_id}Reititettävä kanavatunniste
senderobjectBotin identiteetti — nimi, rooli, botId
textstringViestin sisältö
attachmentsarrayTiedostot, kuvat, ääni
reply_toUUID v7Ylätason viestin ID ketjutusta varten
actionsarrayInteraktiiviset painikkeet/näppäimistöt
platform_databytesLäpinäkymätön läpivienti alustakohtaisille ominaisuuksille
timestampISO 8601Julkaisija asettaa tämän

Kaksikerroksinen rakenne: Yhteiset kentät (text, attachments, reply_to, actions) kattavat 90 % työntekijän aloittamasta viestinnästä. Alustakohtaiset ominaisuudet menevät kenttään platform_data — laajennuksesi muuntaa ne alustan omaan muotoon ja takaisin.

Keskusteluvirrat

Kanavaviestit reititetään eristyksen vuoksi kanavakohtaisia keskusteluvirtoja pitkin:

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

Go-esimerkki — Telegram-kanava

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

Lisää kykyjä

Comm-sovellus

Ilmoita "provides": ["comm"] ja "permissions": ["comm:*"]. Comm-sovellukset mahdollistavat viestinnän tekoälytyöntekijöiden välillä.

KenttäKuvaus
fromLähettäjätyöntekijän ID
toVastaanottajatyöntekijän ID
topicViestin aihe/kanava
type"message", "mention", "proposal", "command", "info", "task"
contentViestin sisältö

Keskeiset toiminnot:

  • Register ilmoittaa tämän tekoälytyöntekijän verkkoon kykyineen
  • Subscribe/Unsubscribe hallitsevat aihetilauksia
  • Receive suoratoistaa saapuvat viestit (palvelinpuolen suoratoisto, kuten kanavissa)
  • Vain yksi comm-sovellus voi olla aktiivisena kerrallaan

Yhdyskäytäväsovellus

Yhdyskäytäväsovellus reitittää LLM-pyynnöt malleille. Ilmoita "provides": ["gateway"] ja "permissions": ["network:outbound", "user:token"].

GatewayRequest sisältää viestit, työkalut, järjestelmäkehotteen, tokenien enimmäismäärän, lämpötilan ja UserContext-kentän (JWT-tunnus, jos user:token-lupa on myönnetty).

GatewayEvent-tyypit:

TyyppiSisältöKuvaus
"text"TekstipalaSuoratoistettava tekstitoken
"tool_call"JSONMalli haluaa kutsua työkalua
"thinking"TekstipalaLaajennettu ajattelu/päättely
"error"VirheilmoitusJokin meni pieleen
"done"TyhjäVirta on valmis

UI-sovellus

UI-sovellus tarjoaa mukautetun määrityskäyttöliittymän, joka avautuu Nebon sisäänrakennettuun selainikkunaan. Ilmoita "provides": ["ui"]. Toisin kuin automaattinen asetuslomake (jonka Nebo piirtää settings-manifestistasi), UI-sovellus tarjoaa oman täyden HTML/CSS/JS-käyttöliittymänsä.

Sovelluksesi mukana toimitetaan ui/-hakemisto, joka sisältää staattiset verkkoresurssit (HTML, CSS, JS — tyypillisesti SPA, jossa on index.html). Nebo tarjoilee nämä tiedostot suoraan ja välittää API-kutsut sovelluksellesi gRPC:n kautta.

PolkuMekanismiTarkoitus
GET /api/v1/apps/{id}/ui/*Staattinen tiedostopalvelinTarjoilee tiedostot ui/-hakemistostasi (SPA-varareitti tiedostoon index.html)
ANY /api/v1/apps/{id}/api/*gRPC-välitysVälittää HTTP-pyynnöt sovelluksesi metodille UIService.HandleRequest()

SDK käärii tavallisen net/http.ServeMux-olion, joten kirjoitat tavallisia Go-HTTP-käsittelijöitä — SDK hoitaa gRPC-siltauksen automaattisesti.

Go-esimerkki — koontinäytön käyttöliittymä:

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

Tiedostosi ui/index.html tekisi fetch-kutsuja osoitteeseen /api/v1/apps/com.example.dashboard/api/status, jotka välitetään mux-käsittelijällesi.

Ajastussovellus

Ajastussovellus korvaa Nebon sisäänrakennetun cron-ajastimen. Ilmoita "provides": ["schedule"] ja "permissions": ["schedule:create"].

Kun ajastussovelluksesi käynnistyy, Nebo reitittää kaiken ajastuksen sovelluksesi kautta oletusarvoisen cron-moottorin sijaan. Jos sovelluksesi kaatuu, Nebo palaa automaattisesti sisäänrakennettuun moottoriin.

  • Sovelluksesi omistaa ajastusten tilan — Nebo ei tallenna ajastuksia omaan tietokantaansa, kun ajastussovellus on aktiivinen
  • Tavallinen CRUD: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers on palvelinpuolen suoratoistava RPC — sovelluksesi lähettää käynnistysviestin aina, kun ajastus laukeaa
  • Vain yksi ajastussovellus voi olla aktiivisena kerrallaan

Monikykyiset sovellukset

Sovellus voi tarjota useita kykyjä. Esimerkiksi koontinäyttösovellus, jossa on sekä työkalu että käyttöliittymä:

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

Paketointi

.napp-muoto

Jakelua varten NeboAI:n kautta paketoi sovelluksesi .napp-tiedostoksi (tar.gz-arkisto):

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

Pakolliset tiedostot:

TiedostoEnimmäiskokoKuvaus
manifest.json1 MBSovelluksen metatiedot
binary tai app500 MBSuoritettava tiedosto
signatures.json1 MBEd25519-allekirjoitukset
TOOL.md1 MBTyökaluohjeet tekoälytyöntekijälle

Purkamisen turvallisuussäännöt:

  • Ei polun ohittamista (../ hylätään)
  • Ei symbolisia linkkejä (hylätään)
  • Ei absoluuttisia polkuja (hylätään)
  • Vain sallittujen luettelon tiedostonimet hyväksytään

Allekirjoitukset

NeboAI allekirjoittaa sovellukset Ed25519:llä. signatures.json-muoto:

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

Kehitystilassa (NeboAI-URL-osoitetta ei ole määritetty) allekirjoituksen vahvistus ohitetaan kokonaan. Et tarvitse tiedostoa signatures.json paikalliseen kehitykseen.

Julkaiseminen

Kun sovelluksesi toimii paikallisesti, julkaise se NeboAI:n kautta jaettavaksi kaikille Nebon käyttäjille.

Kehittäjätilin käyttöönotto

  1. Rekisteröi NeboAI-tili osoitteessa POST /api/v1/owners/register
  2. Kirjaudu sisään saadaksesi JWT-tunnuksen: POST /api/v1/owners/login
  3. Luo kehittäjätili: POST /api/v1/developer/accounts

Lähetyksen kulku

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

Vaihe 1: Luo sovellus

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

Vaihe 2: Lataa alustakohtaiset binäärit

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"

Lataa yksi binääri alustaa kohden: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Vaihe 3: Lähetä tarkistettavaksi

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

Tarkistusprosessi

  1. Automaattinen skannaus — binäärit skannataan VirusTotalilla
  2. Ylläpitäjän tarkistus — NeboAI-tiimi tarkistaa metatiedot, manifestin ja skannauksen tulokset
  3. Hyväksyttäessä — NeboAI allekirjoittaa sovelluksen Ed25519:llä ja julkaisee sen
  4. Hylättäessä — saat perustelun ja voit korjata ja lähettää uudelleen

Tavoiteltu tarkistusaika: <24 tuntia.

Päivitysten julkaiseminen

  1. Päivitä sovelluksen versio: PUT /api/v1/developer/apps/{id} uudella versiolla
  2. Lataa uudet binäärit jokaiselle alustalle
  3. Lähetä uudelleen tarkistettavaksi

Jokainen päivitys käy läpi saman tarkistusprosessin. Aiemmat versiot pysyvät saatavilla, kunnes uusi versio hyväksytään.

Kaupan metatiedot

KenttäKuvaus
categoryesim. productivity, communication, developer-tools
iconSovelluskuvakkeen URL
visibilitypublic tai private
descriptionVoi olla pidempi ja monipuolisempi kuin manifestin kuvaus

Kehitystyönkulku

Paikallinen kehitys

Paikallinen kehitys ei vaadi paketointia:

  1. Luo sovelluksesi hakemisto:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Kirjoita manifest.json ja koodi
  3. Rakenna binäärisi:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo havaitsee uuden hakemiston automaattisesti (tai käynnistä Nebo uudelleen)
  5. Rakenna binääri uudelleen koodimuutosten jälkeen — tiedostovahti käynnistää sovelluksen uudelleen

Lokien tarkastelu

Sovelluksen stdout/stderr tallennetaan sovelluskohtaisiin lokitiedostoihin:

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

Pysyvä data

Käytä data/-hakemistoa (saatavilla myös ympäristömuuttujana NEBO_APP_DATA) kaikille tiedostoille, jotka sovelluksesi tarvitsee säilyttää. Tämä hakemisto säilyy sovelluspäivitysten ja karanteenin yli.

Vianetsintävinkkejä

  • Jos sovelluksesi ei käynnisty, tarkista virheet tiedostosta logs/stderr.log
  • Varmista, että binääri on suoritettava (chmod +x binary)
  • Varmista, että kuuntelet Unix-socketin polkua, joka on muuttujassa NEBO_APP_SOCK
  • Socketin on oltava valmis 10 sekunnin kuluessa käynnistyksestä
  • Käytä tallennukseen muuttujaa NEBO_APP_DATA, älä kovakoodattuja polkuja
  • Tulosta stderr-virtaan vianetsintälokitusta varten (tallennetaan tiedostoon logs/stderr.log)

Tarkistaminen

# 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

Asennuksen poistaminen

nebo apps uninstall com.example.myapp

Taidot

Mitä taidot ovat

Taidot ovat ohjejoukkoja, jotka muokkaavat Nebon toimintaa keskustelun aikana. Kun taito on aktiivinen, sen sisältö lisätään suoraan järjestelmäkehotteeseen — ja se ohjaa tekoälytyöntekijän sävyä, menetelmiä, alan asiantuntemusta ja työkalujen käyttöä kyseisen istunnon ajan.

Taidot eivät ole koodia. Ne ovat markdown-dokumentteja, joissa on YAML-metatiedot. Ei kääntämistä, ei binääriä, ei gRPC:tä. Taito on SKILL.md-tiedosto hakemistossa. Siinä kaikki.

Taidot ovat tilannekohtaisia ja väliaikaisia. Ne aktivoituvat, kun ne ovat olennaisia (käynnistimen osuman tai manuaalisen latauksen kautta), pysyvät voimassa muutaman vuoron ja vanhenevat, kun niitä ei enää tarvita. Näin tekoälytyöntekijän konteksti pysyy kevyenä — kehotteessa on vain juuri nyt merkityksellinen ohjeistus.

Taidot täydentävät sovelluksia. Sovellukset tarjoavat suoritettavia kykyjä (työkalut, kanavat, yhdyskäytävät). Taidot tarjoavat ohjeistusta niiden yhteiskäyttöön — miten työkaluja käytetään tehokkaasti. Kalenterisovellus antaa Nebolle kyvyn lukea ja kirjoittaa tapahtumia. ”Kokoukseen valmistautuminen” -taito kertoo Nebolle, miten kokouksiin valmistaudutaan käyttämällä kalenterisovellusta, sähköpostia ja verkkohakua yhdessä.

Taidot vs. sovellukset

TaidotSovellukset
MuotoMarkdown (SKILL.md)Käännetty binääri (.napp)
Ajonaikainen ympäristöLisätään järjestelmäkehotteeseenHiekkalaatikoitu prosessi gRPC:n kautta
TarjoaaToimintaohjeistusta, menetelmiäTyökalut, kanavat, käyttöliittymäpaneelit
ElinkaariIstuntokohtainen, vanhenee TTL:n perusteellaAina käynnissä
LuominenKirjoita markdown-tiedostoKirjoita, käännä, allekirjoita, paketoi
TietoturvaLupia ei tarvitaOletuksena kaiken kieltävä hiekkalaatikko

Pika-aloitus

Luo Nebon taitokansioon hakemisto, jossa on SKILL.md-tiedosto:

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

Kirjoita 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 seuraa taitohakemistoa fsnotify-työkalulla. Taitosi on käytettävissä heti — uudelleenkäynnistystä ei tarvita. Sano jotain, mikä vastaa käynnistintä, niin se aktivoituu automaattisesti.

Tai pyydä Neboa suoraan: ”Luo taito blogikirjoitusten kirjoittamiseen” — Nebo kirjoittaa SKILL.md-tiedoston puolestasi.

SKILL.md-muoto

Jokainen taito on yksi SKILL.md-tiedosto, jossa on kaksi osaa: YAML-etuosa ----merkkien välissä sekä markdown-runko (varsinaiset ohjeet, jotka lisätään järjestelmäkehotteeseen).

KenttäPakollinenOletusKuvaus
nameKyllä—Yksilöllinen tunniste (muuttuu slugiksi)
descriptionKyllä—Yksirivinen kuvaus, joka näytetään taitoluettelossa
versionEi"1.0.0"Semver päivitysten seurantaan
authorEi—Taidon tekijä
priorityEi0Suurempi = osuu ensin (100+ kriittisille ohituksille)
max_turnsEi4Toimettomien vuorojen määrä ennen automaattista vanhenemista
triggersEi[]Lausekkeet, jotka aktivoivat tämän taidon automaattisesti (kirjainkoosta riippumaton osamerkkijonovastaavuus)
toolsEi[]Työkalut, joita tämä taito odottaa käyttävänsä (tiedoksi)
dependenciesEi[]Muut taidot, jotka on oltava asennettuina
tagsEi[]Luokittelua ja löydettävyyttä varten
platformEi[]Tuetut alustat: macos, linux, windows (tyhjä = kaikki)

Miten taidot aktivoituvat

Taidot noudattavat kaksivaiheista aktivointimallia: ensin vihje, sitten kutsu.

Vaihe 1: Käynnistimien vastaavuus — Aina kun käyttäjä lähettää viestin, Nebo käy läpi kaikki rekisteröidyt taidot käynnistinosumien varalta. Vastaavat taidot näkyvät vihjeinä järjestelmäkehotteessa. Tekoälytyöntekijä näkee vihjeen ja päättää, kutsuuko se taitoa.

Vaihe 2: Kutsu — Tekoälytyöntekijä kutsuu taitoa näin:

skill(name: "code-review")

Tämä palauttaa koko SKILL.md-mallin työkalun tuloksena, kirjaa kutsun ja lisää mallin uudelleen järjestelmäkehotteeseen seuraavilla vuoroilla.

TTL ja vanheneminen:

  • Automaattisesti osuneet taidot: 4 toimetonta vuoroa (määritettävissä max_turns-kentällä)
  • Manuaalisesti ladatut taidot: 6 toimetonta vuoroa
  • Uudelleenkutsu nollaa ajastimen
  • Ehdoton raja: enintään 4 aktiivista taitoa istuntoa kohden
  • Token-budjetti: aktiivisten taitojen yhteenlaskettu sisältö enintään 16,000 merkkiä

Taitojen hallinta

Tekoälytyöntekijä voi hallita taitoja skill-työkalulla:

ToimintoKuvausEsimerkki
catalogListaa kaikki käytettävissä olevat taidotskill(action: "catalog")
loadAktivoi tähän istuntoonskill(name: "code-review", action: "load")
unloadPoista taito käytöstäskill(name: "code-review", action: "unload")
createLuo uusi taito levylleskill(action: "create", content: "...")
updatePäivitä olemassa oleva taitoskill(name: "my-skill", action: "update", content: "...")
deletePoista taito levyltäskill(name: "my-skill", action: "delete")

Hyvien taitojen kirjoittaminen

Hyvässä taitomallissa on:

  1. Selkeä otsikko — kertoo tekoälytyöntekijälle, missä tilassa se on
  2. Perusperiaatteet — ehdottomat toimintasäännöt
  3. Menetelmät — vaiheittainen lähestymistapa yleisiin tilanteisiin
  4. Esimerkit — konkreettiset mallit käyttäjän viestistä vastaukseen
  5. Vastamallit — mitä EI pidä tehdä (mallit oppivat hyvin kielteisistä esimerkeistä)

Vinkki: Jokaisen taidon pitäisi tehdä yksi asia hyvin. Älä luo ”yleisohjelmointi”-taitoa — luo code-review, debugging ja api-design erillisinä taitoina. Tekoälytyöntekijällä voi olla useita aktiivisina samanaikaisesti.

Mukana tulevat taidot

Nebon mukana tulee taitoja, jotka kattavat yleiset käyttötapaukset:

TaitoPrioriteettiKuvaus
onboarding100Uuden käyttäjän tervehdys ja profiilitietojen keruu
best-friend50Persoonallisuustaito — rento, lojaali, suoraa puhetta
debugging25Järjestelmällinen vianetsintämenetelmä
api-design15RESTful-API-suunnittelun parhaat käytännöt
code-review10Jäsennelty koodikatselmointi vakavuustasoineen
database-expert10Tietokantasuunnittelu, kyselyt, optimointi
git-workflow10Git-haarat, commitit, PR-työnkulut
security-audit10Tietoturva-analyysi ja haavoittuvuuksien tunnistus

Nämä toimivat sekä hyödyllisinä oletuksina että mallitoteutuksina omien taitojen luomiseen.

Viite

Proto-tiedostot

Proto-tiedostot sijaitsevat hakemistossa proto/apps/v0/. SDK:iden mukana tulee valmiiksi generoitu koodi, joten et tarvitse protocia tavalliseen kehitykseen.

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

Jokainen palvelu sisältää RPC:t HealthCheck ja Configure. SDK hoitaa molemmat automaattisesti.

Kanavien proto-tyypit

ViestityyppiKuvaus
ChannelSendRequestLähtevän viestin kuori, jossa on message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseAlustan viestin ID ketjutusta varten
InboundMessageSaapuvan viestin kuori, jossa on kaikki yhteiset kentät + aikaleima
MessageSenderBotin identiteetti (name, role, botId) — välittäjä täydentää
AttachmentTiedosto-, kuva- tai ääniliite (type, url, filename, size)
MessageActionInteraktiivinen painike- tai näppäimistötoiminto (label, callback_id)

Botin identiteetti ja roolit

Nebo-boteilla on kolmiulotteinen identiteettimalli:

  • creature — Mikä botti on (arkkityyppi): ”Nokkela strategi”, ”Huolellinen tutkija”
  • role — Miten se suhtautuu käyttäjään (suhde): ”Ystävä”, ”COO”, ”Mentori”
  • vibe — Sen energia (viestintätyyli): ”Rento mutta vahvoja mielipiteitä”, ”Lämmin ja kannustava”

Kun kanavalaajennuksesi vastaanottaa lähtevän viestin, sender-kenttä sisältää botin name- ja role-arvot. Käytä niitä näyttönimen muotoiluun alustallesi. Rooli ei ole työnimike — se kuvaa suhdetta. ”Ystävä”, ”Poika” ja ”Mentori” ovat kelvollisia rooleja siinä missä ”COO” ja ”DevLead”.