PRAXO-CORE

English | 简体中文

A public, MIT-licensed agent framework for the AxisVela ecosystem.

PRAXO-CORE provides the reusable primitives behind PRAXOVELA and other
AxisVela agents: models, tools, memory, events, scheduling, policy, sandboxing,
checkpoints, the runtime plugin plane, and the agent loop. It is a framework,
not a product.

One-liner: build governed agents without rebuilding the loop, provider
abstraction, tool contracts, or memory/event boundaries.

Comparison: PRAXO-CORE vs other Go agent frameworks
(LangChainGo, Eino, Google ADK Go, Microsoft Agent Framework Go).

Framework, Not Product

The MIT boundary lets PRAXOVELA and external products embed the framework
without inheriting AGPL obligations. PRAXOVELA remains an AGPL product.

Who It's For

PRAXO-CORE fits products that need a governed agent loop with explicit policy,
sandbox, checkpoint, memory, event, and plugin boundaries. It is a good fit when
you want to embed these contracts in your own runtime and keep provider and
product adapters under your control.

It is not a hosted agent service, a model provider, a vector database, or a
turnkey chat UI.

AxisVela Ecosystem

PRAXO-CORE is the framework layer of the AxisVela family. It is not tied to a
single product: the same interfaces connect models, memory, events, retrieval,
policy, sandboxing, tools, and graph execution to the corresponding AxisVela
components. Concrete adapters and credentials stay with the product or
integrator.

NOETIVELA is the AxisVela inference fabric and can back the model seam through
a model.Model or model.Provider adapter. Other AxisVela control planes
(identity, assurance, HITL, capabilities, twins, planning, coordination) plug in
through tools, events, or product-runtime adapters rather than core primitives.

Adapters are optional and product-owned; the framework never imports product
code. See AxisVela ecosystem integration, the
adapter skeletons, the
runnable wiring demo, and the
real NOETIVELA SDK example.

Module

github.com/axisvela/praxo-core/v2 (v2 semantic import path). The v1 tags
remain available for consumers that have not migrated; see the
v2 migration guide.

Quickstart

Requires Go 1.26+ and an OpenAI-compatible endpoint. From this repository:

# Ollama (no API key required)
export PRAXO_BASE_URL=http://localhost:11434/v1
export PRAXO_MODEL=llama3.2
GOWORK=off go run ./examples/quickstart

# Any OpenAI-compatible endpoint
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

On PowerShell use $env:PRAXO_BASE_URL = "..." and the same variable names.
Set PRAXO_PROMPT to change the request. The model adapter uses only the
standard library; no provider SDK is required. The example demonstrates tool
calling, events, and policy.

Optional adapters:

• adapters/openaicompat - standard-library
  OpenAI-compatible model adapter
• adapters/mcp - optional MCP tool gateway module

For SDK-backed integrations, see
examples/ecosystem-sdk (NOETIVELA, Mnemovela,
GNOSIVELA).

Primitives

• pkg/model - model/provider abstraction and messages.
• pkg/tool - tool contracts and registry; pkg/tool/jsonschema validates schemas.
• pkg/toolcall - model-output tool-call parsing and markup stripping.
• pkg/memory - memory and context interfaces.
• pkg/event - event envelopes and sinks.
• pkg/scheduler - schedule definitions and scheduler engine.
• pkg/policy - decision hooks, authorization boundary, and path containment.
• pkg/sandbox - execution sandbox interface.
• pkg/checkpoint - durable run snapshots and the resume store contract.
• pkg/httpclient - shared retry-capable HTTP transport for adapters.
• pkg/formatter - language formatter detection and execution.
• pkg/flow - Runnable, Chain, and Parallel composition.
• pkg/prompt - prompt and chat templates.
• pkg/retriever - document retrieval contracts.
• pkg/vfs - virtual filesystem backend contract, confined local backend, and filesystem tools.
• pkg/plugin - runtime plugin contracts, manifest v1, lifecycle, registry, hosts, and conformance kit.
• pkg/agent - the governed agent loop with middleware, budgets, context compaction, and subagent management. Capability packages live under pkg/agent/{types,context,delegation,evaluation,hitl,middleware,stream}; root aliases keep agent.* imports source-compatible.

How It Compares

The Go agent ecosystem has several strong frameworks. This table is a
high-level orientation based on public documentation as of October 2026;
upstream projects evolve quickly, so verify details before adopting.

PRAXO-CORE is deliberately lower-level: it does not bundle provider SDKs,
vector databases, or an MCP client. It is also the only framework here with
first-class AxisVela seams; other frameworks can still integrate AxisVela
through custom adapters or tools. Choose PRAXO-CORE when you need a small,
MIT-licensed governance and runtime boundary to embed, or native access to
NOETIVELA, Mnemovela, Harmovela, GNOSIVELA, AEGIVELA, RHEOVELA, and LIMENORA.
Choose LangChainGo, Eino, or ADK when you want batteries-included integrations
and orchestration patterns. See the full comparison for
positioning and "when to choose" guidance.

Example

ag, err := agent.New(agent.Options{
    Model:    myModel,
    Tools:    tools,
    Events:   sink,
    Policy:   hook,
    MaxSteps: 8,
})
if err != nil {
    return err
}
result, err := ag.Run(ctx, agent.Session{
    ID: "session-1",
    TenantID: "acme",
    WorkspaceID: "default",
}, "Inspect the failing test and propose a fix")

See examples/integrator for a self-contained
external-integrator example, and examples/reference for a
workspace agent with confined VFS tools, policy, memory, and events.

Status

2.0.0 was released on 2026-10-18. It changes only the module path to
github.com/axisvela/praxo-core/v2; the exported API is functionally identical
to 1.7.0 (api/2.0.0.txt; the 1.7.0 diff is module-path updates only). The
1.0.0 API freeze remains in effect, and the canonical package paths are
pkg/toolcall, pkg/formatter, and pkg/tool/jsonschema. The 1.x line adds
plugin hosts, the conformance kit, Manifest v1, path containment, context budget
compaction, context summarization/offload, VFS tools, async subagents,
structured output, PII redaction, HITL decisions, typed streams, and todo
planning. The framework is extracted from PRAXOVELA's proven runtime.

Documentation

Documentation site |
简体中文文档

• Comparison with other Go agent frameworks
• Benchmarks
• AxisVela ecosystem integration
• Overview
• Architecture
• Primitives
• Integration
• License and provenance
• Compatibility
• v2 migration
• Security policy
• API freeze inventory
• Security model
• Release process
• Plugin authoring
• Roadmap detail
• Roadmap

Internal extraction planning and product-family sequencing live in the private
PRAXOVELA-EE repository.

License

MIT. See LICENSE.