machine infrastructure for execution, payments, proof, and integration.
naxytra gives agents, developers, and enterprises one public stack for machine-native execution, payment, proof, and followthrough. It is built to be easy to adopt from CLI, API, browser, chat, or embedded flows, and explicit where consequence matters.
One system. Two product surfaces.
xytara is the runtime and payment engine. xoonya is the proof and review spine. Together they form the public naxytra stack with clean ownership instead of one blurred product surface.
- xytara owns execution, quoting, payment flows, delivery, lifecycle visibility, and integration posture.
- xoonya owns result-package review, governance, bridge continuity, and proof-side followthrough.
Built for transactions that carry consequence.
A machine transaction is more than a request and a response. It has cost, continuity, proof, and review. naxytra is built for that fuller shape so quoting, payment, execution, and followthrough stay explicit.
- Execution, payment, proof, governance, and bridge continuity.
- Designed for runtime operation on one side and explicit followthrough on the other.
Where should you start?
Start with xytara for runtime systems, xoonya for proof and governance evaluation, and naxytra itself when you want the full system view first.
- Builders and operators: start with xytara.
- Proof, review, and governance evaluators: start with xoonya.
- System-level evaluators: start with naxytra.
- Public entry works from CLI, browser, chat, API, or embedded product paths.
Already live.
The repos are public. The npm packages are live. The current release line is already out. This is an arrival surface for a stack that exists now rather than a placeholder for later.
- xytara@3.1.0 live on npm.
- xoonya@3.1.0 live on npm.
- GitHub releases and public docs are already available.
One-line paths into the real stack.
After install, the public starting points are intentionally simple. naxytra gives the shortest umbrella entry path, while xytara and xoonya keep their focused runtime and proof entry paths underneath.
- npm install naxytra
- naxytra start-here
- npm install xytara
- xytara start-here
- npm install xoonya
- xoonya start-here
Catalog and integration breadth are explicit.
The public stack already carries 27 xytara integrations and 6 xoonya proof integrations, alongside first-class lane families for providers, frameworks, protocols, canonical rails, major rails, payment and settlement lanes, proof bridge, telemetry, provenance, artifact distribution, shared signals, feature control, and interface and interop contracts.
The live map is public.
The home page should help a new evaluator move immediately into the stack, the first-run flow, and the evidence surfaces that back the claim. The live map is not hidden in docs or release notes; it is one click away from the same pages we verify after deploy.
- Start with the stack split if you want runtime and proof ownership in one view.
- Use the first-run path for the shortest public builder loop.
- Use the operator shell for the commercial control surface.
- Use the catalog and proof pages to inspect the live matrices directly.
- Use the releases page to see the deploy and release signals behind the line.
- Use the claim page to inspect the full catalog claim itself.
- Use the final 3.0.0 contract and gate surfaces to inspect the launch bar directly.
Stack · Start · Agents · Catalog · Proof · Claim · 3.0.0 contract · 3.0.0 gates · Operator shell · Go-live · Money-in · Site map
Payments and pricing are simple on purpose.
The public model is designed to reduce adoption friction without giving away the value layer. Discovery and onboarding stay easy. Execution and consequence stay paid. Pricing stays quote-based so the same stack can serve both lightweight usage and high-consequence work.
- Free: docs, discovery, auth, install, evaluation, and low-friction first contact.
- Paid: execution, funded workflows, repeated automation, and high-consequence operations.
- Payment options: direct machine pay, hosted checkout, or reusable credits depending on the caller path.
- Pricing posture: quote first, then pay or spend credits, then execute and receive proof-aware outputs.