Arqen

Backend infrastructure for agent-ready applications

Arqen is a developer-focused backend toolkit with typed tools, durable jobs, discoverable APIs, and thingd integration. It is for teams building services that need a clear HTTP boundary, explicit application state, operational signals, and automation-friendly contracts.

“Agent-ready” does not mean AI-only. It means an application is discoverable, typed, permission-aware, auditable, and automation-friendly for people, programs, and agents alike.

Status

Arqen is early-stage. The repository contains working Rust crates and examples alongside contracts and planned work. The Rust implementation uses Axum, Tokio, Tower, tracing, and native thingd adapters. Native thingd migration, public HTTP parity, and CLI/template completion remain important maturity gates. Read the feature status before relying on a feature.

The public product positioning is language-agnostic. Rust is the first implementation; future Node.js support can arrive through the public HTTP API, SDKs, templates, and shared manifests without making application users learn Rust.

Quickstart

Most applications can start with the single public facade crate:

[dependencies]
arqen = "0.1"

The source remains modular internally, while the public distribution stays focused on one package.

From a checkout:

cargo run -p arqen-cli -- new hello-api --template thingd-app
cd hello-api
cargo run

For the workspace server itself:

cargo run -p arqen-cli -- dev --storage memory
curl http://127.0.0.1:3000/health

The current CLI also supports start, check, and doctor. dev currently starts the server and prints the documented cargo watch loop; it does not yet provide an integrated watcher.

Architecture

Application, client, or agent
              |
       Axum HTTP boundary
              |
  typed tools · policies · jobs · logs
              |
       Arqen adapter contract
        /         |          \
   memory     native durable   HTTP sidecar
  development   thingd        thingd service
                                  |
                         future optional cloud API

The same application-facing contracts are intended to work across four deployment modes:

What makes Arqen distinct

Arqen is the layer between an ordinary backend and the software that needs to operate it. It does not replace a web framework, an AI model runtime, a hosted BaaS, or a standalone workflow engine. It gives those systems a shared, inspectable contract for capabilities, data, jobs, and operations.

• Compared with a traditional web framework, Arqen makes tools, manifests, permissions, jobs, health, and auditability first-class.
• Compared with an agent framework, Arqen is model-agnostic. Agents are clients of the application rather than the application’s architecture.
• Compared with a BaaS, Arqen keeps deployment and adapter boundaries visible instead of requiring a hosted control plane.
• Compared with a workflow engine, durable jobs are one backend primitive alongside HTTP, storage, tools, logs, and readiness.
• Compared with a microservice stack, Arqen starts with one explicit application boundary and adds sidecars or cloud adapters only when useful.

See Why Arqen? for the detailed comparison.

Explore the docs

• About Arqen · Why Arqen? · Use cases
• Feature status · Architecture · Roadmap
• Getting started · Commands · Configuration
• Agent guide · Agent discovery · Typed tools
• Operations · Docker · Security · Release
• Contributing · FAQ

The full documentation site is available at sayanmohsin.github.io/arqen.

License

Arqen is licensed under the MIT License.