跳转到主要内容
Chinese, Simplified

category

正文

At 3 a.m., an Erlang service is still running: a telecom switch, a messaging path, or an uptime-sensitive platform.

This is the setting in telecom, messaging, and uptime-sensitive services. The service already has supervision, failure semantics, and operational knowledge. Adding a new Python runtime moves policy, approval, and credentials outside the system the team knows how to supervise.

The default answer is to put the agent in a Python service and call Erlang as a tool.

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 Erlang/OTP 29 process, and put a governed agent loop inside it.

What native Erlang means

The implementation is Erlang/OTP 29. It is not a bridge to Python or Go, and it is not a hosted service.

Current distribution: Hex praxo_core_erlang 0.9.0; source tag erlang/v0.9.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.

OTP 29 and its json module. The library does not create processes, mailboxes, supervisors, or restart strategies for you.

Architecture

Surface Purpose
praxo_agent loop, options, tool helpers, fallback model
praxo_models messages, sessions, events, decisions, stream kinds
praxo_sink, praxo_memory event sinks and in-memory store
praxo_checkpoint, praxo_runtime checkpoints, paths, token estimation
praxo_toolcall, praxo_jsonschema tool parsing and schema validation
praxo_plugin, praxo_middleware manifests, PII redaction, structured output, limits

The entry point is praxo_agent:run_agent/3:

Model = praxo_agent:static_model(<<"hello">>),
Options = praxo_agent:new_agent_options(Model),
{ok, Result, _} = praxo_agent:run_agent(
    Options, praxo_models:session(<<"demo">>), <<"hello">>).

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 Erlang/OTP 29, 11 shared vector groups, OpenAI adapter, SSE, parallel tools, OTel, retriever, delegation, process plugin host.
  • Explicit limits rather than hidden behavior.

A passing vector suite is contract evidence. It is not production readiness or an independent consumer.

Boundaries

  • Synchronous loop; tools run serially.
  • Caller owns supervision and failure handling.
  • Tool registry and JSON Schema remain partial; stream part is parity.
  • No hosted provider runtime.

The honest scope also includes partial surfaces:

  • Tool registry common path is covered; not every optional Go hook.
  • JSON Schema covers the declared vector behavior, not the full specification.
  • The library is not an OTP application or supervision tree.

These are not footnotes. They are the boundary that lets an operator decide whether the integration fits.

Governance

For telecom, messaging, and uptime-sensitive services, the question is not whether Erlang 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

  1. Install or build the current release from the language README.
  2. Run the conformance vectors, native tests, and API snapshot.
  3. Test final-argument authorization, denial, cancellation, and callback failure.
  4. Check the partial surfaces against the workflow you actually run.
  5. 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/erlang/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/erlang-predictable-failure-agent-deep-dive

Conclusion

A native Erlang 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 telecom, messaging, and uptime-sensitive services, the useful question is where the final authorization belongs — and whether this boundary can be stated clearly enough to operate.

本文地址
最后修改
星期六, 十一月 21, 2026 - 18:21
Article
↑