category
At 3 a.m., an Erlang service is still running: a telecom switch, a messaging path, or an uptime-sensitive platform.
This is not a toy workload. It sits in telecom, messaging, and uptime-sensitive services, where the system is old enough to have change control and important enough that nobody wants to rediscover its edge cases. 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.
Default answer one: migrate
The first default answer is to put the agent in a Python service and call Erlang as a tool.
Migration can be correct. But for a system that already owns transactions, operational knowledge, and audit history, migration is a revalidation program, not a syntax cleanup.
Default answer two: bridge
The second default answer is a sidecar. The Erlang/OTP 29 program exposes a tool or API, and a new service owns the agent loop.
This is often the right engineering choice. It isolates the new runtime and avoids touching fragile code. But the governance boundary moves with the agent. Policy, approvals, credentials, checkpoints, and audit events now cross a process or network boundary.
The third path: keep the runtime
PRAXO-CORE puts the loop where the work already lives.
The application calls praxo_agent:run_agent/3 with options, a session, and a prompt. Model callbacks, tools, policy, and events remain in the same process or runtime. The loop is a library; the application still owns the provider, tools, policy content, and deployment.
What native Erlang means
The implementation is Erlang/OTP 29. Distribution: Hex praxo_core_erlang 0.9.0; source tag erlang/v0.9.0.
The Core is not a hosted service. It does not own credentials or tenant data. It provides a governed execution boundary, and the application provides the business controls around it.
Architecture highlights
- Native Erlang/OTP 29.
- 11 shared vector groups.
- OpenAI adapter, SSE, parallel tools, OTel, retriever, delegation, process plugin host.
The important design choice is not the number of modules. It is that the final tool arguments are reauthorized after edits, denials leave zero effects, and events can be audited.
The limits are the design
- 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.
These limits make failure modes reviewable. A bridge or sidecar may still be better when isolation, deployment ownership, or team boundaries matter more than an in-process loop.
Governance
For telecom, messaging, and uptime-sensitive services, the question is not “Can Erlang call a model?” It is whether an agent can participate in a regulated or operational process without bypassing the controls around it.
The Core handles execution. The application still owns identity, policy decisions, approvals, effect records, isolation, shutdown, and the meaning of the tool call.
What we did not do
- We did not claim full Go parity.
- We did not claim a hosted agent platform.
- We did not claim production readiness or a security certification.
- We did not claim that migration or a bridge is obsolete.
Invitation
If you run telecom, messaging, and uptime-sensitive services, I would value the hard questions. What would you test first? Which boundary should stay native, and which should remain behind a bridge or sidecar? What evidence would you need before letting an agent touch a production tool?
A useful answer can be “a sidecar is the right fit.” The goal is an honest integration boundary, not one architecture for every system.
Repo: https://github.com/axisvela/praxo-core
Language docs: https://axisvela.github.io/praxo-core/languages/erlang/
Canonical: https://architect.pub/erlang-predictable-failure-agent-deep-dive
- 登录 发表评论