category
Disclosure: I maintain PRAXO-CORE. This article reflects the 2.10.0 source state; it is not a production or security certification.
The default answer for Delphi and AI is to rewrite the application in C#/.NET or add a sidecar.
That can be the right answer. A sidecar isolates the new runtime, and a hosted platform removes operational work. But it also moves policy, approval, audit, and credentials across a process or network boundary.
PRAXO-CORE is testing a narrower claim: keep the existing Windows application, and put a governed agent loop inside it. The loop is a library. The provider, tools, policy content, and deployment remain the application’s responsibility.
What native Delphi means
The implementation is Free Pascal / Delphi. It is not a hosted service, and it is not a claim that every integration should be native.
Current distribution: source tag delphi/v0.8.0; OPM 0.2.1. The shared contract targets SPEC_VERSION 0.2.0. The Core is MIT-licensed; the language runtime and external toolchain keep their own licenses.
Architecture
| Surface | What it provides |
|---|---|
praxo_core.pas |
loop, options, sessions, policy, tools, events |
praxo_mcp.pas |
MCP client |
| Adapters | OpenAI-compatible, Anthropic, Gemini, OTel, retriever, delegation |
The important boundary is not the number of APIs. 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.
- API snapshot and parity inventory.
- Native tests and a language-specific CI gate.
- OpenAI-compatible, Anthropic, and Gemini streaming where the language README records it.
- Explicit limits instead of hidden behavior.
A passing vector suite is contract evidence. It is not production readiness, a security certification, or an independent consumer.
Boundaries
- Free Pascal 3.2.2 verified.
- Commercial Delphi unverified.
- OPM 0.2.1; listing pending.
- No hosted runtime.
These limits are part of the design. They make failure modes reviewable. A bridge or sidecar can still be the better choice when isolation, deployment, or team ownership matters more than an in-process boundary.
The integration boundary
A native loop is not free. The application still needs build and link integration, tool callbacks, policy content, approval handling, and observability. A sidecar is not free either: every policy, approval, credential, and effect crosses a process or network boundary.
The useful question is not “native or sidecar?” in the abstract. It is which boundary the team can operate when the model is wrong, a tool times out, or an approval arrives after the effect.
Failure modes that matter
- Final arguments edited after approval must be reauthorized, not silently executed.
- A denied call must produce zero tool effects.
- Cancellation before a tool call must not be confused with cancellation after the effect.
- Provider and transport failures must propagate as errors, not as empty success.
- An upgrade must preserve the application’s required behavior, not only the vector count.
What it does not claim
- Commercial Delphi compatibility.
- A hosted agent platform.
- Production readiness.
- A security certification.
- A bridge is obsolete.
- Every integration should embed the loop.
Governance
For Windows enterprise teams, the question is not “Can Delphi 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 and model choice;
- identity and policy decisions;
- durable approvals and effect records;
- isolation, deployment, and shutdown;
- the business meaning of a successful tool call.
How to evaluate
- build with the recorded Free Pascal toolchain
- run the native tests and API snapshot
- check commercial Delphi compatibility separately
- decide whether native embedding or a sidecar is the right boundary
Repo: https://github.com/axisvela/praxo-core
Language docs: https://axisvela.github.io/praxo-core/languages/delphi/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/delphi-native-agent-runtime
Invitation
The interesting question is not whether Delphi can call a model. It is whether a governed loop can fit the runtime, release process, and failure model that the team already trusts.
If you work on Windows enterprise teams, I would value the hard questions. What would you test first? Which boundary should stay native, and which should stay behind a bridge or sidecar? What would you need to see before letting an agent call a production tool?
That conversation is more useful than another generic agent-framework comparison.
- 登录 发表评论
- 2 次浏览