Sign in Join

Live chat for Free Pascal, Lazarus, Delphi and every Pascal programmer.

Catalog · How the catalog works
Anything · Lazarus or Delphi
Random projectRandom project

praxo-core

MIT-licensed agent framework for the AxisVela ecosystem: governed agent loop, model/tool/memory/event primitives, plugins, sandboxing, and policy.

View on GitHub

Member rating

No ratings yet.

Sign in to rate this project.

README

PRAXO-CORE

English | 简体中文

An embeddable MIT-licensed agent framework with explicit policy controls, checkpoints, and event tracing.

Build governed agents inside your own product without rebuilding the agent loop, model abstraction, tool contracts, or execution boundaries. Use your own model providers and integrations. AxisVela products are not required.

Documentation | Quickstart | Language Implementations | Examples

Start With Go

bash
go get github.com/axisvela/praxo-core/v2@v2.5.2

First verify the independent Go consumer: create your own application with the published package and run deterministic allow/deny tests. No source checkout, API key, or model service is required.

Then run the endpoint quickstart from a checkout using Ollama:

bash
export PRAXO_BASE_URL=http://localhost:11434/v1
export PRAXO_MODEL=llama3.2
GOWORK=off go run ./examples/quickstart

Or connect an OpenAI-compatible endpoint:

bash
export PRAXO_BASE_URL=https://api.openai.com/v1
export PRAXO_API_KEY=...
export PRAXO_MODEL=gpt-4o-mini
GOWORK=off go run ./examples/quickstart

Use Go 1.26.10, the tested CI/release toolchain. On PowerShell, set environment variables with $env:PRAXO_BASE_URL = "..." and the same names. The example demonstrates tools, streamed text, events, and policy. See the quickstart guide for prerequisites.

Why PRAXO-CORE

  • Explicit governance: policy hooks, tool authorization, and HITL decisions.
  • Recoverable execution: checkpoint and session contracts with resume support.
  • Observable behavior: structured events and optional OpenTelemetry integration.
  • Provider-neutral embedding: model, memory, tool, retrieval, and sandbox interfaces.
  • MIT boundary: optional integrations stay separate from the core framework.

Implements, Verifies, Requires

Governed, Embeddable Agent Execution Kernel describes an embedding boundary, not a turnkey enterprise security system. The table describes the Go reference; other languages have separately declared capabilities and evidence.

Area What Core Implements What Tests Verify What the Consumer Must Supply
Governed Policy hooks, tool authorization and HITL integration Configured allow/deny and approval paths Authentication, policy configuration and enforcement; an Agent can run without Policy
Sandbox support Execution contracts and adapters Contract behavior and selected adapter boundaries A real isolated runtime and deployment hardening; an interface is not OS isolation
Recoverable Session/checkpoint contracts and recovery integration Serialization and scoped recovery fixtures Durable stores, effect verification and idempotency; checkpoints are not external transactions or exactly-once guarantees
Multilingual Shared specification and independent implementations Each language's declared vectors and behavior coverage Selection against that language's limitations; not assumed Go feature parity
Multi-agent Local subagent delegation Delegation behavior in the declared suites Distributed coordination and durable orchestration if needed

See the test taxonomy for evidence levels and the consumer starters for package-level checks.

One Kernel supports three integration levels: Standard Embedding (existing behavior), Governed Execution Profile (proposed acceptance design with partial evidence), and Embodied Integration Profile (proposed design; consumer pilot not started). They are not separate packages or runtime switches. Required governance is enforced by trusted product entry points and actual effect boundaries, not by a profile name.

It is a framework, not a hosted agent service, vector database, model provider, or turnkey chat UI. Review the adoption guide, security model, and framework comparison before choosing it.

Choose Your Language

Go is the reference implementation. Core implementations share a normative contract in spec/, with language-specific APIs and declared limitations.

Runtime Start here
Go Install and quickstart
Python Python Core
TypeScript / JavaScript TypeScript Core, JavaScript sample
Java / Kotlin / Scala / Groovy / Clojure Java Core, Kotlin, Scala, Groovy, Clojure
.NET C# Core, Visual Basic sample, F# sample
C / OpenCL C Core, OpenCL sample
OCaml OCaml Core
MATLAB / Octave MATLAB/Octave Core
Haskell Haskell Core
Delphi / Free Pascal Delphi / Free Pascal Core
Other languages Complete implementation directory

Source releases, package-registry publication, conformance, and production verification are different states. Follow each language's installation instructions and support policy; do not infer full Go feature parity or registry availability from a source tag.

Behavior coverage is tiered separately from contract tier. Agent-capable implementations are Go, Python, TypeScript, Java, Rust, R, and C#; extended implementations are PHP, C, Fortran, COBOL, Ruby, Elixir, Erlang, C++, and Lua; other declared implementations are optional. See the behavior lab for current coverage.

Examples

Goal Example
Call a model with tools and streaming Quickstart
Observe approval and denial boundaries Governed workspace
Resume a run Checkpoint
Gate command execution through policy Sandbox
Delegate work Multi-agent
Embed with your own adapters Integrator

Repository Map

Location Purpose
pkg/ Public Go framework APIs
adapters/ Optional model, protocol, telemetry, and runtime integrations
language/ Independent language Core source, builds, tests, and API references
bindings/ Shell and PowerShell runtime bridges
spec/ Normative wire contract, vectors, and parity inventories
examples/ Runnable integration examples
docs/ Public documentation grouped by user task

Go module paths remain unchanged. Language sources have moved under language/, bindings/, and examples/; see the source migration guide.

Framework and Ecosystem

PRAXO-CORE is an independent MIT-licensed framework.

Connect models, memory, events, retrieval, and policy through your own adapters or optional AxisVela integrations. See the adapter directory for module scope and limitations.

Releases and Contributing

Core 2.5.2 is a security and behavior patch release covering rooted local VFS operations, governed examples, context trust, the OpenTelemetry example, verification evidence, and conformance gates. Optional adapters and Core implementations are versioned independently.

GitHub Latest Release represents only the Go Reference Core (vX.Y.Z). Language and adapter releases use independent tags and registry versions, not Latest.

License

MIT. See LICENSE and provenance.