DEV Community: Korvus

An AI shopkeeper NPC for your Roblox game

Korvus — Mon, 31 Aug 2026 12:17:36 +0000

A shopkeeper that actually answers questions about your items — "which sword is best against armor?" — feels alive in a way a static menu never does. Here's the minimal version.

Give the NPC your catalog

Put your item list in the system prompt so the NPC only talks about things that exist:

local ai = Cortex.new("YOUR_KEY")

local persona = [[
You are Marta, a cheerful blacksmith's apprentice. You sell:
- Iron Sword (balanced), Warhammer (slow, heavy damage), Dagger (fast, weak).
Answer player questions in one or two short, in-character sentences. Never invent items.
]]

local reply = ai:ask(persona, playerMessage)

Make it hold up in a real game

Per-player memory so Marta remembers what a player already asked.
A cooldown per player so nobody can spam her.
Filter her replies before showing them.

With the Cortex kit that's an NPC object with memory and moderation built in:

local marta = ai:npc({ personality = persona, moderate = true })
local reply = marta:say(player, playerMessage)

Free and open source: https://github.com/cortex-rbx/roblox-ai-kit

Smart Roblox enemies that react to what the player actually does

Korvus — Sat, 29 Aug 2026 12:42:31 +0000

Scripted enemies repeat the same three lines forever. You can make a boss that taunts you about how you're fighting instead — no dialogue tree, generated at runtime.

Feed the model the game state

The trick is turning the current situation into a short prompt:

local state = ("The player has %d HP left, is using a %s, and has dodged %d attacks.")
    :format(player.Health, weaponName, dodgeCount)

local taunt = ai:ask(
    "You are a smug arena boss. Taunt the player in one short line based on the situation.",
    state
)

Now the boss says different things when you're low on health versus when you're winning — because it's reading the actual state, not a fixed script.

Keep it cheap and safe

Cache by a rounded state so similar situations reuse a line instead of paying again.
Rate-limit per player so a spammer can't run up your usage.
Filter the output before it appears over the enemy's head.

The open-source Cortex kit handles caching, per-player limits, and moderation for you: https://github.com/cortex-rbx/roblox-ai-kit

5 ways to actually use AI in your Roblox game (2026)

Korvus — Thu, 27 Aug 2026 13:53:14 +0000

"AI in Roblox" usually means a chatbot NPC and nothing else. There's a lot more you can wire up with one server request or a Studio plugin. Here are five that are genuinely useful.

1. Talking NPCs with memory

A shopkeeper that remembers what you asked, a quest-giver that reacts to your choices. The trick most tutorials miss is per-player state — one global variable and every player shares the same conversation. Key it by UserId.

2. Adaptive quests

Generate quest text and objectives on the fly, then cache identical prompts so you're not paying for the same quest twice. Endless content, tiny cost.

3. Chat moderation by meaning

Word-list filters miss creative spelling and block innocent words. A model judges intent — "is this message harmful?" — and catches what a blocklist can't.

4. Generating Luau inside Studio

This is the newest one and my favorite: a plugin where you type "a healing potion that gives +25 HP" and it writes the Tool + script and drops it in your place. It reads your selection too, so it can edit the script you have open.

5. Items, lore, and names

Procedural item stats, weapon names, world lore — anything text-shaped — generated as structured data your game can read.

The common piece

All five come down to one thing: a safe way to call a model from your game or Studio, with per-player state, retries, caching, and moderation handled for you. That's what Cortex packages up.

Kit + plugin: github.com/cortex-rbx/roblox-ai-kit
Free beta key: discord.gg/A3MSqwkvn7

Free open beta. Build one of these and tell me how it went.

An AI script generator that lives inside Roblox Studio

Korvus — Thu, 27 Aug 2026 13:53:13 +0000

Searching for a Roblox AI script generator? Most of them are a website where you paste a prompt, copy the code back, and paste it into Studio by hand. I wanted the opposite: describe what I want, and have it appear in my place.

That's Cortex — a Studio plugin that turns plain English into Luau and runs it right there.

Type English, get working Luau

› a part that kills the player on touch

Cortex writes it and runs it:

local part = Instance.new("Part")
part.Size = Vector3.new(8, 1, 8)
part.Anchored = true
part.Parent = workspace

part.Touched:Connect(function(hit)
    local h = hit.Parent:FindFirstChildOfClass("Humanoid")
    if h then h.Health = 0 end
end)

No copy-paste. It's in your Workspace, and Ctrl+Z removes it like any Studio edit.

Things it's good at

Boilerplate you hate typing — RemoteEvents, DataStore scaffolds, Tool setups.
Editing the script you have open — select a script, say "add a debounce", it patches the source.
Prototyping — "spinning platform", "day/night cycle", "sprint on Shift" — one line each.

How it works

It's a plugin that calls a small gateway routing to frontier models (Claude, GPT-5). Generated code runs via loadstring (with a ModuleScript fallback), and every change is wrapped in ChangeHistoryService so Undo/Redo behave normally.

Try it (free beta)

Plugin + kit: github.com/cortex-rbx/roblox-ai-kit
See the terminal: cortex-rbx.github.io/cortex.html
Free key in the Discord: discord.gg/A3MSqwkvn7

Open beta — free for early testers. If it writes something wrong, tell me; that's exactly the feedback I need.

I built an AI that writes and runs Luau inside Roblox Studio

Korvus — Thu, 27 Aug 2026 12:41:53 +0000

Roblox Studio scripting is mostly boilerplate. You already know what you want — a healing potion that gives +25 HP, a door that opens when a player is near — but you still hand-write the Instance tree, wire the events, and wade through the property soup.

So I built Cortex: an AI terminal that lives inside Studio. You type what you want in plain English, it turns that into Luau, and runs it right in your place. Made a mistake? Ctrl+Z, like any other Studio action.

What it feels like

› make a healing potion that gives +25 HP
✻ Thinking…
⎿ applied Luau
   + HealingPotion (Tool) → StarterPack
   + heal server script
✔ done · Ctrl+Z to undo

It reads your current selection too. Select a script, say "make it respawn the player on death", and it edits that script's .Source in place — you're not copy-pasting snippets back and forth.

What it generated for that request

local tool = Instance.new("Tool")
tool.Name = "HealingPotion"
tool.RequiresHandle = false
tool.Parent = game.StarterPack

local s = Instance.new("Script", tool)
s.Source = [[
  script.Parent.Activated:Connect(function()
    local h = script.Parent.Parent:FindFirstChildOfClass("Humanoid")
    if h then h.Health = math.min(h.MaxHealth, h.Health + 25) end
  end)
]]

Under the hood

It's a Studio plugin that calls a small gateway routing to frontier models (Claude, GPT-5).
The generated Luau runs via loadstring, with a ModuleScript require fallback.
Every change is wrapped in ChangeHistoryService, so Undo/Redo just works.
No account, no config — install and go.

Why not just use Studio's built-in Assistant?

Roblox's own AI is handy for snippets, but Cortex builds in your place and reads your actual selection and context. It's less "chat that hands you code to paste" and more "say what you want and it's there." Different tool for a different moment.

Try it (free, open beta)

Kit + plugin loader: github.com/cortex-rbx/roblox-ai-kit
What the terminal looks like: cortex-rbx.github.io/cortex.html
Grab a free beta key in the Discord: discord.gg/A3MSqwkvn7

Honest note: it's an open beta — free keys for early testers, no 24/7 uptime guarantee yet. If you try it and it breaks, tell me; that feedback is the whole point right now.

Calling a ChatGPT-style API from a Roblox game (server-side)

Korvus — Thu, 27 Aug 2026 12:18:18 +0000

You can give a Roblox game real generated text — dialogue, quests, item names — with a single HTTP request. The catch is where you make it.

HttpService, from the server only

local HttpService = game:GetService("HttpService")

local ok, res = pcall(function()
    return HttpService:PostAsync(ENDPOINT, HttpService:JSONEncode({
        system = "You are a wise shopkeeper. One sentence.",
        text = "what do you sell?",
    }), Enum.HttpContentType.ApplicationJson, false, { Authorization = "Bearer " .. KEY })
end)

Turn on Game Settings → Security → Allow HTTP Requests first, or every call fails.

The limits you will hit

500 requests/min per server. Cache repeated prompts so you don't burn the budget.
No SSE streaming in live games. Streaming only works in Studio; live servers are request/response.
Moderation. Anything player-facing must be filtered, or your game risks removal.

A shortcut

The Cortex kit wraps all of this — one key, caching, retries, and moderation on by default, billed in Robux instead of a credit card. But the pattern above works with any backend. Open source: https://github.com/cortex-rbx/roblox-ai-kit

How to make an AI NPC in Roblox Studio (the multiplayer-safe way)

Korvus — Tue, 25 Aug 2026 15:58:41 +0000

Most "AI NPC" tutorials work great in a solo test and then fall apart the moment two players are in the server. Here's how to do it so it actually holds up.

The one request

AI text generation happens on the server. Never call it from a LocalScript — your API key would ship to every client. Put a ModuleScript in ServerStorage and call it from a server Script:

local Cortex = require(game.ServerStorage.Cortex)
local ai = Cortex.new("YOUR_KEY")

local line = ai:ask("You are a gruff blacksmith. One short line.", "forge me a sword?")
print(line) --> "Aye, hand over the ore and I'll hammer ye a blade."

The three bugs that only show up in multiplayer

Global debounce. Tutorials use one shared isBusy flag, so only the first player to talk gets a reply and everyone else is dropped. Fix: cooldown keyed by UserId, not a global lock.
No retries. The endpoint 429s under load and one failed request kills the interaction. Fix: retry with backoff.
Unfiltered output. Raw model text shown to players can get your game moderated. Fix: run replies through TextService:FilterStringAsync before displaying.

Doing it right, briefly

If you want per-player memory and the fixes above handled for you, the open-source Cortex kit gives you an NPC object:

local bramm = ai:npc({ personality = "You are Bramm, a dwarven blacksmith.", moderate = true })
local reply = bramm:say(player, message)              -- per-player memory + cooldown
local safe  = ai:filterForPlayer(reply, player)       -- Roblox-filtered, safe to show

Code is MIT and readable: https://github.com/cortex-rbx/roblox-ai-kit

You don't need a credit card to add AI to your Roblox game

Korvus — Tue, 25 Aug 2026 06:15:45 +0000

Most "add AI to your game" tutorials assume you'll sign up for OpenAI with a credit card, host a proxy, and eat per-token bills in dollars. But a Roblox game earns Robux, not dollars — and plenty of Roblox devs are teenagers without a card at all.

Here's the mismatch nobody addresses: your revenue is Robux, your AI bill is USD, and the two don't meet.

Pay for AI the same way your game earns

Cortex is built for this: you pay in Robux via a game pass, no card. The API key never leaves your server, and you're billed on output tokens only — the system prompt, memory, and chat history you resend on every call are free, and repeated replies are cached for nothing.

local Cortex = require(game.ServerStorage.Cortex)
local ai = Cortex.new("YOUR_KEY")
print(ai:ask("You are a gruff blacksmith. One line.", "forge me a sword?"))

That's the whole integration — one function, one server-side request, and it works for NPCs, quests, item text, and chat moderation.

It's OpenAI-compatible, so if you ever outgrow it you point your SDK somewhere else and only the address and key change.

Free open beta, keys in the Discord: https://discord.gg/A3MSqwkvn7 · kit: https://github.com/cortex-rbx/roblox-ai-kit

Generate endless Roblox quests with AI (and cache them so it's cheap)

Korvus — Sun, 23 Aug 2026 12:17:03 +0000

Hand-written quests run out. Players finish your content faster than you can write it, and the tenth "collect 10 wolf pelts" quest feels like filler. You can generate quests on the fly instead — tuned to the player and the place.

One request

local Cortex = require(game.ServerStorage.Cortex)
local ai = Cortex.new("YOUR_KEY")

local quest = ai:ask(
    "Give one short side-quest for a forest zone, player level 5. One sentence.",
    "player just entered the forest"
)
print(quest)
--> "Find the woodcutter who vanished near the old mill before nightfall."

Same pattern generates item names, descriptions, and lore.

Cache the world, not the player

World-gen content (an item's description, a location's lore) is generated once and then it's fixed — so cache it and never pay for it again. With Cortex, cached repeats are free and you're billed on output tokens only, so a world full of generated flavor text costs almost nothing. Pay in Robux, key stays server-side.

Free beta + open-source kit: https://github.com/cortex-rbx/roblox-ai-kit · demo: https://cortex-rbx.github.io

AI chat moderation in Roblox — by meaning, not a word list

Korvus — Sun, 23 Aug 2026 12:16:33 +0000

Word-list chat filters break the moment someone types a s s a s s i n with spaces, or a slur spelled with a 0, or a perfectly innocent word that happens to contain a banned substring. You end up in an endless arms race patching your blocklist.

An AI model reads the meaning of a message, so it catches obfuscated toxicity and stops false-flagging harmless phrases.

One server-side call

local Cortex = require(game.ServerStorage.Cortex)
local ai = Cortex.new("YOUR_KEY")

local verdict = ai:ask(
    "You moderate a kids' game chat. Reply with exactly one word: SAFE or BLOCK.",
    message
)
if verdict == "BLOCK" then
    -- don't send it
end

The reply is one word, so it's cheap: with Cortex you're billed on output tokens only, and repeated messages are served from cache for free — so moderating your whole chat costs a fraction of a Robux. You pay in Robux, no credit card, and the key stays server-side.

Tips

Give the model your game's context ("kids' game", "PvP trash-talk is fine") so it matches your tolerance.
Cache identical messages — spammers repeat themselves.
Log BLOCK verdicts so you can tune the prompt.

Free open beta and open-source kit: https://github.com/cortex-rbx/roblox-ai-kit · demo: https://cortex-rbx.github.io

Add AI-powered talking NPCs to your Roblox game (one server request)

Korvus — Sun, 23 Aug 2026 11:57:42 +0000

Static dialogue trees get old the second a player types something you
didn't predict. Here's how to give any Roblox NPC a real brain — one that
answers in character to whatever the player actually writes — with a
single server-side request.

## The idea

If you put an API key in a LocalScript, it ships to every player and
gets scraped in minutes. Every AI call must go from a server Script,
and you must enable Game Settings → Security → Allow HTTP Requests.

## One request


lua
  local HttpService = game:GetService("HttpService")

  local function ask(personality, playerMessage)
      local body = HttpService:JSONEncode({ system = personality, text =
  playerMessage })
      local res = HttpService:PostAsync("YOUR_AI_ENDPOINT", body)
      return HttpService:JSONDecode(res).text
  end

  print(ask("You are a gruff dwarven blacksmith. One short in-character
  line.",
            "can you forge me a sword?"))
  --> "Aye — hand over the ore and I'll hammer ye a blade."

  Swap the personality string and you have a merchant who haggles, a guard
  who warns you off, a priest who blesses you.

  Paying for it without a credit card

  Roblox devs earn Robux, not dollars, and plenty don't have a card to hand
  to OpenAI. So I built Cortex (https://cortex-rbx.github.io) — the same
  one-request idea, but you pay in Robux, the key stays server-side, and
  you're billed on output tokens only (the system prompt, memory and
  history you resend every call are free, and repeated lines are cached
  free — NPCs say a lot of similar things).

  local Cortex = require(game.ServerStorage.Cortex)
  local ai = Cortex.new("YOUR_KEY")
  print(ai:ask("You are a gruff blacksmith. One short line.", "forge me a
  sword?"))

  It's not just dialogue

  - Adaptive quests tuned to the player's level and story
  - Item names, descriptions and lore generated once and cached
  - Chat moderation by meaning (SAFE / BLOCK) — catches intent word-lists
  miss
  - An in-game assistant that explains a mechanic in words that fit the
  moment

  Try it

  - Live demo (a real model, not a scripted reply):
  https://cortex-rbx.github.io
  - Free open-source kit: https://github.com/cortex-rbx/roblox-ai-kit
  - Free beta key: https://discord.gg/A3MSqwkvn7

  Open beta, free right now. Would love feedback on the API and what you'd
  want your NPCs to say.