category
The host is a game engine, a network appliance, an IoT control plane, or an application with a Lua plugin system.
This is the setting in embedded hosts, games, appliances, and IoT control planes. The host may not allow a new process. A Python sidecar may not exist, may not be permitted, or may be too heavy. The extension already owns the state and the business hooks.
The default answer is to add a Python sidecar, or move the host to a new runtime.
That can be right. A sidecar isolates the new runtime, and a hosted platform removes operational work. But it moves policy, approval, audit, and credentials across a process or network boundary. For a system whose value is the control around the transaction, that is a larger change than it first appears.
PRAXO-CORE takes a narrower path: keep the Lua 5.4 process, and put a governed agent loop inside it.
What native Lua means
The implementation is Lua 5.4. It is not a bridge to Python or Go, and it is not a hosted service.
Current distribution: LuaRocks praxo-core 0.8.0-1; source tag lua/v0.8.0. The shared contract targets SPEC_VERSION 0.2.0. The Core is MIT-licensed; the language runtime and external toolchain keep their own licenses.
Lua standard library only. No Python host, no provider SDK, no compiled extension for the core loop.
Architecture
| Surface | Purpose |
|---|---|
praxo.agent |
loop, options, tool registry, function tools |
praxo.models |
messages, sessions, events, decisions, stream kinds |
praxo.runtime |
paths, memory, checkpoints, context budget, event sinks |
praxo.toolcall |
tool-call parsing and markup stripping |
praxo.jsonschema |
schema validation |
praxo.plugin |
manifest parsing |
praxo.middleware |
limits, fallback, redaction, structured output |
The entry point is agent.run_agent:
local agent = require('praxo.agent')
local models = require('praxo.models')
local model = agent.static_model('hello')
local options = agent.agent_options(model)
local result = agent.run_agent(options, models.session({id='demo'}), 'hello')
print(result.output)
The important boundary is not the API count. It is where the final tool call is authorized, where approval is recorded, and where the audit event is emitted.
Evidence
- 11 shared vector groups.
- Native tests and a language-specific CI gate.
- API snapshot and parity inventory.
- Native Lua 5.4, Standard library only, OpenAI, Anthropic, Gemini, SSE, OTel, retriever, delegation.
- Explicit limits rather than hidden behavior.
A passing vector suite is contract evidence. It is not production readiness or an independent consumer.
Boundaries
- Lua 5.4 only; LuaJIT, 5.1, 5.3, OpenResty, and Redis are not claimed.
- Event sink, stream part, and JSON Schema remain partial.
- No plugin host; manifest parsing only.
- No persistent session store.
The honest scope also includes partial surfaces:
- Event sink covers the common path, not every optional Go hook.
- Stream kinds are represented, but this is not an async runtime.
- JSON Schema covers the declared vector behavior, not the full specification.
These are not footnotes. They are the boundary that lets an operator decide whether the integration fits.
Governance
For embedded hosts, games, appliances, and IoT control planes, the question is not whether Lua can call a model. It is whether an agent can touch a production tool without bypassing policy, approval, audit, or change control.
The Core provides the execution boundary. The application still owns provider credentials, identity, durable approvals, effect records, isolation, deployment, and the business meaning of a successful tool call.
How to evaluate
- Install or build the current release from the language README.
- Run the conformance vectors, native tests, and API snapshot.
- Test final-argument authorization, denial, cancellation, and callback failure.
- Check the partial surfaces against the workflow you actually run.
- Decide whether a native loop, a bridge, or a sidecar is the right boundary.
Repo: https://github.com/axisvela/praxo-core
Language docs: https://axisvela.github.io/praxo-core/languages/lua/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/lua-embedded-host-agent-deep-dive
Conclusion
A native Lua loop is not a claim that every integration should be native. It is a way to keep the governance boundary close to the work when the runtime already owns the transaction, the model, or the host.
If you run embedded hosts, games, appliances, and IoT control planes, the useful question is where the final authorization belongs — and whether this boundary can be stated clearly enough to operate.
- 登录 发表评论
Tags
最新内容
- 15 minutes 15 seconds ago
- 15 minutes 43 seconds ago
- 16 minutes 21 seconds ago
- 16 minutes ago
- 17 minutes ago
- 17 minutes 22 seconds ago
- 17 minutes 36 seconds ago
- 17 minutes ago
- 18 minutes 58 seconds ago
- 19 minutes ago