跳转到主要内容
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 the setting in operations, telecom, finance, bioinformatics, and internal tooling. The script holds credentials, paths, retry logic, exception rules, and operational knowledge. Rewriting it in Python is not syntax cleanup; it is a migration.

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

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 Perl 5.20+ process, and put a governed agent loop inside it.

What native Perl means

The implementation is Perl 5.20+. It is not a bridge to Python or Go, and it is not a hosted service.

Current distribution: CPAN Praxo::Core 0.7.0; source tag perl/v0.7.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.

Perl core modules only: JSON::PP, File::Spec, and Cwd. 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, checkpoint allowlist, context budget, event sinks
Praxo::Toolcall tool-call parsing and markup removal
Praxo::JsonSchema schema validation
Praxo::Plugin manifest parsing
Praxo::Middleware call limits, fallback, PII redaction, structured output

The entry point is run_agent:

use Praxo::Agent ();
my $options = Praxo::Agent::AgentOptions->new($model);
my $result = Praxo::Agent::run_agent(
    $options, Praxo::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 Perl 5.20+, not a Python wrapper, Core modules only: JSON::PP, File::Spec, Cwd, OpenAI-compatible, Anthropic, Gemini, MCP, 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

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

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 operations, telecom, finance, bioinformatics, and internal tooling, the question is not whether Perl 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/perl/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/perl-glue-layer-agent-deep-dive

Conclusion

A native Perl 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 operations, telecom, finance, bioinformatics, and internal tooling, the useful question is where the final authorization belongs — and whether this boundary can be stated clearly enough to operate.

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