跳转到主要内容
Chinese, Simplified

category

正文

At 2 a.m., a bank's nightly batch is still running: job scheduling, reconciliation, the general ledger, and reports.

This is the setting in banking, insurance, government, and airlines. A load-bearing batch program is not just code. It holds transactions, reconciliation, audit trails, and change-control knowledge that have survived for decades because they work.

The default answer is to migrate the COBOL to Java or C#, or put the agent in a Python or Java 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 GnuCOBOL 2.0+ process, and put a governed agent loop inside it.

What native COBOL means

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

Current distribution: source tag cobol/v0.8.0; no package-registry release. The shared contract targets SPEC_VERSION 0.2.0. The Core is MIT-licensed; the language runtime and external toolchain keep their own licenses.

GnuCOBOL 2.0+ at runtime; Python 3.10+ only for the test driver. A compiled consumer does not need Python.

Architecture

Surface Purpose
praxo-run agent loop, options, session, policy, tools, events
praxo-json-*, praxo-utf8 bounded JSON and UTF-8
praxo-jsonschema declared object/array schema subset
praxo-toolcall JSON, XML-style, dotted-tag, and plain tool calls
praxo-middleware step limits, tool selection, fallback, structured output, email redaction
praxo-memory in-memory session records and search
praxo-checkpoint, praxo-context checkpoint envelopes and context budget
praxo-policy, praxo-path-normalize lexical path grants and normalization
praxo-plugin, praxo-stream manifest validation and stream-kind constants

The entry point is praxo-run:

call "praxo-run" using px-options px-session px-prompt
    px-result px-user-data

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 GnuCOBOL, not a bridge, 63 normative vectors across 11 groups, 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

  • JSON input: 32,768 bytes, 512 nodes, 64 nesting levels; generated JSON: 16,384 bytes.
  • Bounded ASCII schema patterns; unsupported patterns fail explicitly.
  • Path policy is lexical, not OS confinement.
  • Email redaction only; not general PII.
  • Synchronous events and streams; not an async runtime.

The honest scope also includes partial surfaces:

  • tool.Registry and several P1 parity rows remain partial.
  • Stream parts and event session/run IDs remain partial.
  • Process plugin host integration is partial through the C ABI.

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

Governance

For banking, insurance, government, and airlines, the question is not whether COBOL 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/cobol/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/cobol-batch-agent-deep-dive

Conclusion

A native COBOL 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 banking, insurance, government, and airlines, the useful question is where the final authorization belongs — and whether this boundary can be stated clearly enough to operate.

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