The Qbox-native AI, not a QBCore renamer

Qbox AI Script Generator

Other FiveM AIs treat Qbox as “QBCore with a different logo.” SwisserAI generates Qbox-native code: qbx_core exports, ox_lib APIs, state-bag driven sync, and ox_inventory by default.

Start Free (250 credits)See Pricing

Qbox, not legacy QBCore

Qbox is not a rename. It is a framework that drops deprecated QBCore code paths, consolidates around the Overextended resource stack (ox_lib, ox_inventory, ox_target, ox_doorlock, oxmysql), and leans into state bags for entity and player sync. Writing it as QBCore with a different export prefix wastes half of what the framework gives you.

Most AI tooling does exactly that. Ask a generic model for a Qbox script and it will emit QBCore.Functions calls, qb-inventory exports, and tick-based sync loops. The code “works” in the weak sense that it compiles, but you end up with a Qbox server running code that fights the framework.

SwisserAI is scoped to the real Qbox surface. Generations use exports.qbx_core, ox_lib for UI and RPC, ox_inventory for items, and state bags where state bags are the idiomatic answer.

Qbox coverage

qbx_core exports

exports.qbx_core:GetPlayer, GetPlayerByCitizenId, and the qbx_core event surface used by modern Qbox resources.

ox_lib by default

lib.notify, lib.callback, lib.registerContext, lib.points — wired without fallback shims.

State bags for sync

Player and entity state bags with proper replication keys. No legacy server-tick sync loops.

ox_inventory first-class

Stash creation, shop hooks, item metadata, and crafting tables using the real ox_inventory API.

Modern money handling

exports.qbx_core:GetMoney and SetMoney with account types ("cash", "bank"). No qb-banking assumptions.

oxmysql queries

exports.oxmysql:query_async / insert / update with prepared statements — no MySQL-Async legacy patterns.

Qbox-idiomatic output

The snippets below are what a SwisserAI Qbox generation actually produces.

Server callback with ox_lib

lib.callback.register is the Qbox-native replacement for CreateCallback.

lib.callback.register('swisser:server:canAfford', function(source, price)
    local player = exports.qbx_core:GetPlayer(source)
    if not player then return false end

    return player.PlayerData.money.bank >= price
end)

Money + ox_inventory

Removes cash and gives the player an item using Qbox + ox_inventory.

RegisterNetEvent('swisser:server:buyRadio', function()
    local src = source
    local player = exports.qbx_core:GetPlayer(src)
    if not player then return end

    local price = 2500
    if not exports.qbx_core:RemoveMoney(src, 'cash', price, 'radio-purchase') then
        lib.notify(src, { title = 'Not enough cash', type = 'error' })
        return
    end

    exports.ox_inventory:AddItem(src, 'radio', 1)
    lib.notify(src, { title = 'Radio acquired', type = 'success' })
end)

State bag for on-duty status

State bags replace tick-based sync: set once on the server, every client sees it.

-- server
RegisterNetEvent('swisser:server:toggleDuty', function()
    local src = source
    local player = exports.qbx_core:GetPlayer(src)
    if not player or player.PlayerData.job.name ~= 'police' then return end

    local duty = not player.PlayerData.job.onduty
    player.Functions.SetJobDuty(duty)
    Player(src).state:set('onDuty', duty, true)
end)

-- client
AddStateBagChangeHandler('onDuty', nil, function(bagName, _, value)
    local ply = GetPlayerFromStateBagName(bagName)
    if ply == 0 then return end
    lib.notify({ title = value and 'On duty' or 'Off duty', type = 'inform' })
end)

ox_target interaction

An in-world prop that opens an ox_inventory stash for the player's gang.

exports.ox_target:addBoxZone({
    coords = vec3(1100.0, -3100.0, -38.9),
    size = vec3(1.5, 1.5, 2.0),
    rotation = 0,
    debug = false,
    options = {
        {
            name = 'swisser:gang_stash',
            label = 'Open Gang Stash',
            icon = 'fa-solid fa-box',
            onSelect = function()
                TriggerServerEvent('swisser:server:openGangStash')
            end,
        },
    },
})

Migrating from QBCore to Qbox with AI

Most QBCore resources run on Qbox unchanged thanks to the compatibility layer — but compatibility is not the same as idiomatic. A script that keeps calling QBCore.Functions in a Qbox server leaves performance and clarity on the table.

Paste a QBCore resource into SwisserAI and ask for a Qbox rewrite. The output uses exports.qbx_core, lib.callback, lib.notify, ox_inventory, and state bags in place of their older equivalents — with diffs small enough to review in one sitting.

Try the Qbox migrator

Qbox mistakes we prevent

Patterns generic AIs keep emitting in Qbox resources.

Treating Qbox as QBCore with a different name

Qbox drops deprecated QBCore functions and doubles down on ox_lib. A generic AI will happily generate QBCore.Functions.CreateCallback in a Qbox resource — which does nothing.

Ignoring state bags

Qbox expects state-bag driven sync for things like duty status, handcuffs, stress. AI that only knows QBCore emits tick loops for the same job.

Wrong inventory API

Defaulting to qb-inventory exports on a Qbox server that runs ox_inventory. SwisserAI detects your inventory and generates matching code.

Shim wrappers that no longer exist

Older tutorials wrap QBCore in exports.qbx_core:GetCoreObject() style calls that were removed. We track the current Qbox public API.

Frequently Asked Questions

Qbox is a community fork that started as a cleaned-up QBCore and has grown into its own framework built around ox_lib and ox_inventory. It keeps broad QBCore compatibility while dropping deprecated code paths and lean-ing into state bags, modern event patterns, and the Overextended resource stack. It is the most actively developed QBCore-compatible framework in 2026.

In most cases, yes. Qbox ships with a compatibility layer so a large percentage of QBCore resources run unchanged or with minor tweaks. SwisserAI can take a QBCore script and emit a Qbox-native version: exports.qbx_core in place of QBCore.Functions, ox_lib notifications instead of TriggerClientEvent("QBCore:Notify", ...), and ox_inventory for item handling. Always test on a staging slot.

Yes — Qbox is designed around ox_lib. The lib.* API behaves identically to ox_lib in any other framework. The difference is that Qbox assumes ox_lib is present and does not ship fallback wrappers, so generated code tends to be cleaner.

Most do, through the compatibility layer. If you are writing a new script though, going Qbox-native gives you better performance and simpler code — SwisserAI will generate that form by default when you select Qbox.

For now, QBCore still has more third-party paid and free scripts. That gap closes every month as more release authors ship Qbox-native builds or just document compatibility. If your server is mostly custom code, Qbox is the forward-looking choice.

Yes. You can paste a qb-core era script into SwisserAI and ask it to bring the code in line with current Qbox idioms — converting callbacks, state handling, and money calls to the modern surface.

Qbox: the qbx_core exports you searched for

Idiomatic Qbox calls exports.qbx_core directly — verified against the current qbx_core source.

exports.qbx_core:GetPlayer(source)

Get the server-side player object from a source id.

local player = exports.qbx_core:GetPlayer(source)
if not player then return end

print(player.PlayerData.citizenid)
player.Functions.RemoveMoney('cash', 500, 'shop-purchase')

Returns nil if the source is not a loaded player — always guard before indexing PlayerData.

exports.qbx_core:GetPlayerByCitizenId(citizenid)

Look a player up by citizen id instead of source.

local player = exports.qbx_core:GetPlayerByCitizenId('ABC12345')
if player then
    -- player is online
end

exports['qb-core']:GetCoreObject() (compat)

The legacy QBCore core object, via the Qbox compatibility bridge.

-- Legacy / compat:
local QBCore = exports['qb-core']:GetCoreObject()

-- Idiomatic Qbox: skip the core object and call exports.qbx_core:* directly,
-- with ox_lib and ox_inventory for everything else.

GetCoreObject is a compatibility shim so old QBCore scripts keep working. New Qbox code should not depend on it.