跳转到主要内容
Chinese, Simplified

category

正文

At 3 a.m., a cron job fails: log cleaning, reporting, reconciliation, or the Perl glue that holds three systems together.

This is not a toy workload. It sits in operations, telecom, finance, bioinformatics, and internal tooling, where the system is old enough to have change control and important enough that nobody wants to rediscover its edge cases. The script holds credentials, paths, retry logic, exception rules, and operational knowledge. Rewriting it in Python is not syntax cleanup; it is a migration.

Default answer one: migrate

The first default answer is to rewrite the glue in Python, or put the agent in a Python sidecar.

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 Perl 5.20+ 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 run_agent 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 Perl means

The implementation is Perl 5.20+. Distribution: CPAN Praxo::Core 0.7.0; source tag perl/v0.7.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 Perl 5.20+, not a Python wrapper.
  • Core modules only: JSON::PP, File::Spec, Cwd.
  • OpenAI-compatible, Anthropic, Gemini, MCP, OTel, retriever, delegation.

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

  • Event sink, stream part, and JSON Schema remain partial.
  • No async runtime.
  • No hosted provider runtime; adapters require caller transports.
  • Not general PII compliance.

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 operations, telecom, finance, bioinformatics, and internal tooling, the question is not “Can Perl 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 operations, telecom, finance, bioinformatics, and internal tooling, 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/perl/
Canonical: https://architect.pub/perl-glue-layer-agent-deep-dive

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