跳转到主要内容
Chinese, Simplified

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 PowerShell and AI is to add a chatbot or a separate Python automation 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 Windows automation workflow, 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 the PowerShell module means

The implementation is PowerShell over the shared C# Core. It is not a hosted service, and it is not a claim that every integration should be native.

Current distribution: source tag powershell/v0.8.0; PowerShell Gallery praxo-core-ps==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
Praxo.Core PowerShell module wrapper over the C# Core
C# Core surfaces agent loop, policy, middleware, MCP, OTel, retriever, delegation
PowerShell examples consumer, HITL, service, representative chain

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

  • Shared C# Core.
  • PowerShell Gallery 0.8.0.
  • No independent PowerShell loop.
  • Windows automation scope.

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

  • An independent PowerShell agent loop.
  • A hosted agent platform.
  • Production readiness.
  • A security certification.
  • A bridge is obsolete.
  • Every integration should embed the loop.

Governance

For Windows operations teams, the question is not “Can PowerShell 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

  1. install the Gallery module
  2. run the consumer allow/deny path
  3. test approval and audit around a real automation step
  4. decide whether the shared C# Core is the right runtime

Repo: https://github.com/axisvela/praxo-core
Language docs: https://axisvela.github.io/praxo-core/languages/powershell/
Matrix: https://github.com/axisvela/praxo-core/blob/main/spec/languages.md
Canonical: https://architect.pub/powershell-native-agent-runtime

Invitation

The interesting question is not whether PowerShell 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 operations 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.

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