An AI that is
born insideyour app

Shaped like an insect, not a brain

A brain is one large thing that must always be present. An insect's nervous system is a chain of small ganglia that keep working when you take the head off. Bela is built the second way — on purpose.

Deterministic reflexes handle the overwhelming majority of real commands. The self-trained network catches the paraphrases nobody wrote down. Behind both sits a socket, not a dependency: the interface the neural fallback plugs into is the same one an LLM adapter will plug into. Cut the head off and the insect keeps walking.

The knowledge base is a periodic pull: every entity you declare has a resolve() that returns its current rows — a Prisma query, a SQL call, an API fetch, your code. A sync failure keeps the last good snapshot rather than degrading the agent.

export default defineAgent({
  entities: {
    Room:     { resolve: () => prisma.room.findMany(),     match: ["number"] },
    MenuItem: { resolve: () => prisma.menuItem.findMany(), match: ["name", "aliases"] },
  },
  tools: [
    tool("orderFood", {
      params:     { qty: number({ default: 1 }), item: entity("MenuItem"), room: entity("Room") },
      utterances: ["order {qty} {item} for room {room}", "{item} for room {room}"],
      run:        ({ item, room, qty }) => api.post("/api/orders", { itemId: item.id, roomId: room.id, qty }),
    }),
    tool("cancelBooking", {
      params:     { guest: entity("Guest") },
      utterances: ["cancel {guest} booking"],
      confirm:    true,          // never runs on a fresh match
      roles:      ["manager"],   // anyone else gets `denied`
      run:        ({ guest }) => bookings.cancel(guest.id),
    }),
  ],
})

It cannot guess, because it was never given the option

Bela cannot touch your database and cannot write SQL. The only things it can do are call functions you explicitly registered, with arguments it has resolved to real rows in your data. Your business rules stay in your app, where you can test them. Four gates sit between a parsed command and a mutation.

Around those: tool handler exceptions are caught and templated into a safe user-facing message, so your error text never leaks; sessions expire on a TTL so stale follow-ups die quietly; a retrain that fails leaves the previous artifact serving; and a corrupted or hand-edited model file fails fast at load with a clear error instead of crashing deep inside prediction. Unmatched input returns an unknown outcome whose reply lists what the agent can do. Never a guess, never chit-chat.

It is already running a hotel

Bela's first production integration is live. It runs inside a deployed hotel & restaurant management system, trained on that property's real data — 99.5% held-out intent accuracy, about one second of training on the box itself — with 26 tools calling the application's own permission-checked server actions.

Staff type the shorthand they actually use, including Roman-Urdu phrasings; Urdu digits normalise to ASCII on their own. Dialogue and confirmations were verified live, and results reach staff over WhatsApp, verified end to end. The integration itself is one config file and one API route.

Mis-parsed phrasings are captured through the correction store and folded into the next retrain, so the model converges on how these staff talk instead of you hand-editing templates forever. Corrections pass the same accuracy gate, so a bad correction cannot degrade the live model.

Bela is v0.0.1 and honest about it. The deterministic engine, the self-trained fallback, the dialogue safety layer and the CLI all work and are covered by 113 passing tests including end-to-end fixtures. On npm today: npm install bela-ai.

Bela is not a better LLM. It is a different shape of tool.

It loses badly outside its shape, and the bold rows are exactly where. Read them before you choose.

If your users need to converse, reason about things outside the app, or chain several unplanned steps — use an LLM. Bela will not get there. If your users need to fire a known action fast, safely, cheaply and offline, Bela is the smaller and stronger tool. The roadmap's LLM adapter exists precisely so you do not have to choose forever.

Big ambitions, still small

Everything below is planned work, stated as such. None of it changes the rule that a trained command keeps working with the network unplugged.