Appearance

ArqenBackend infrastructure for agent-ready applications.

Typed tools, durable jobs, discoverable APIs, and thingd integration for services that people, programs, and agents can operate.

Get started →
GitHub
Feature status
thingd.cloud
◈

Typed tools

Make application capabilities discoverable with structured inputs, outputs, permissions, and audit metadata.

↻

Durable jobs

Model retries, leases, idempotency, and dead letters at a clear application boundary.

◫

Shared manifests

Publish endpoints, tools, jobs, and runtime metadata for clients and agents to inspect.

≋

Useful logging

Start with tracing, request visibility, redaction guidance, health, and readiness signals.

✓

Health by default

Keep liveness and readiness visible to local development, CI, and deployment systems.

→

Deployment paths

Move from memory mode toward native durable thingd, an HTTP sidecar, or a future cloud contract.

Early-stage project

Arqen is Rust-first and actively maturing. The core framework and CLI are implemented in one package, but production adoption still requires validating durability, public thingd compatibility, security, and operational behavior for the application being built. Check the feature status before adopting a capability.

Rust-first implementation, language-agnostic direction ​

The current implementation uses Rust, Tokio, Tower, tracing, and native thingd adapters, with Axum as an internal HTTP transport. The application positioning stays language-agnostic: future Node.js support can use the public HTTP API, SDKs, templates, and shared manifests.

Start locally ​

bash
cargo run -p arqen --features cli --bin arqen -- new hello-api
cd hello-api
cargo run

Or run the workspace server directly:

bash
cargo run -p arqen --features cli --bin arqen -- dev --storage memory
curl http://127.0.0.1:8888/health

Architecture ​

text
client or agent → Arqen API → typed tools / policies / jobs / logs
                              ↓
              memory · native durable thingd · HTTP sidecar · future cloud

Application code should depend on domain interfaces and the public thingd contract, not private cloud modules. See architecture and thingd integration.

thingd integration ​

thingd supplies the storage, events, search, links, and queue boundary that Arqen adapts. Arqen keeps that integration optional and public-contract based; cloud hosting is a future path rather than a current promise.

Learn more about the thingd ecosystem at thingd.cloud, the home for thingd’s hosted data engine and related services.

A different layer ​

Arqen is not another model runtime or hosted backend. It is the contract layer between an application and the software that operates it:

  • web frameworks get typed tools, manifests, permissions, jobs, and health;
  • agent frameworks get a model-agnostic application boundary;
  • BaaS products get an explicit adapter and deployment model;
  • workflow systems get an HTTP, storage, and observability home;
  • microservice stacks get a clear starting boundary before sidecars multiply.

Read Why Arqen? for the tradeoffs and the honest maturity boundary.

Roadmap ​

Read the roadmap and the Phase 17 specification on GitHub for implementation evidence and open work.

Performance ​

Read the performance guide for benchmarks, profiling, and optimization patterns.

Rust-first implementation · language-agnostic application positioning

© 2026 Arqen contributors · MIT License