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 Haskell and AI is to adopt a hosted platform or put the loop in a Python service.
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 Haskell service, 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 Haskell means
The implementation is Haskell. It is not a hosted service, and it is not a claim that every integration should be native.
Current distribution: source tag haskell/v0.8.0; Hackage praxo-core==0.8.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.
Architecture
| Surface | What it provides |
|---|---|
| Haskell Core modules | loop, options, sessions, events |
| Policy / middleware | tool scope, approvals, limits |
| Adapters | OpenAI, Anthropic, Gemini, MCP, 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
- Haskell library.
- Hackage 0.8.0.
- GHC 9.12.2.
- No hosted agent platform.
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
- A hosted agent platform.
- Production readiness.
- A security certification.
- Laziness or performance superiority.
- A bridge is obsolete.
- Every integration should embed the loop.
Governance
For Haskell teams, the question is not “Can Haskell 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
- install from Hackage
- run native tests and API snapshot
- test denial and cancellation
- 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/haskell/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/haskell-native-agent-runtime
Invitation
The interesting question is not whether Haskell 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 Haskell 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 次浏览