跳转到主要内容
Chinese, Simplified

category

正文

A validated numerical model is still running: simulation, energy, aerospace, actuarial work, or a research code with years of regression cases.

This is the setting in research, simulation, HPC, energy, and aerospace. Porting the model to Python is not a refactor. It is a revalidation program: numerical kernels, libraries, performance profiles, and validation history all move.

The default answer is to port the model to 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 Fortran 2008 process, and put a governed agent loop inside it.

What native Fortran means

The implementation is Fortran 2008. It is not a bridge to Python or Go, and it is not a hosted service.

Current distribution: source tag fortran/v0.11.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.

GNU Fortran at runtime; Python 3.10+ only for fixture translation and the test driver. A compiled consumer does not need Python.

Architecture

Surface Purpose
praxo_types, praxo_interfaces messages, sessions, tools, policy, event sinks
praxo_agent, praxo_context bounded loop, context budget, compaction
praxo_json, praxo_schema bounded JSON and declared schema subset
praxo_toolcall JSON, XML-style, dotted-tag, and plain tool calls
praxo_policy, praxo_plugin lexical paths and manifest validation
praxo_middleware, praxo_stream limits, fallback, redaction, stream kinds
praxo_checkpoint, praxo_runtime checkpoint envelopes and event sinks

The entry point is run_agent:

options%provider => provider
options%tools => tools
options%events => sink
call run_agent(options, state, 'hello', run_id, result, error)
if (error%failed()) print *, error%code

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 Fortran 2008, 63 normative vectors across 11 groups, OpenAI-compatible adapter, SSE, 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: 262,144 bytes, 4096 nodes, 64 nesting levels.
  • Bounded JSON Schema subset; stream part is parity, some stream options partial.
  • PII redaction is pattern-based.
  • No MPI, OpenMP, GPU, netCDF, or HDF5 integration claim.

The honest scope also includes partial surfaces:

  • The bounded JSON Schema subset remains partial.
  • Some P2 stream options remain partial; the stream part itself is parity.
  • No asynchronous runtime.

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

Governance

For research, simulation, HPC, energy, and aerospace, the question is not whether Fortran 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/fortran/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/fortran-model-agent-deep-dive

Conclusion

A native Fortran 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 research, simulation, HPC, energy, and aerospace, the useful question is where the final authorization belongs — and whether this boundary can be stated clearly enough to operate.

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