AquilaMesh: an in-house runtime for multi-agent orchestration

AquilaMesh is a runtime kernel built by Coresis to execute structured cognitive work with operational guarantees. It didn't start as an interface with a backend or a task planner that later had agents bolted on: the starting point was how to operate delegated work seriously.

The problem it solves is concrete: receive an intention formalized as a contract, compile it into an explicit plan with execution semantics, run it with policies, approvals, retries, and recovery, and persist state, events, artifacts, and operational projections that let you audit what happened and why.

Innovation lab

AquilaMesh comes out of Coresis's innovation lab: the practice of building in-house what the market hasn't solved yet, testing it first on our own products, and offering it to clients only once it's sustaining real operation.

It's proprietary technology owned by Coresis, in active development since early 2026. It's currently in preview and already runs a consumer of its own: the Lummiere hotel platform. That sequence is deliberate — it works at home first, then it gets offered.

Roadmap

• Preview (current): an operational runtime with a proprietary consumer in production, contract and integration test suites, continuous integration with deterministic history replay, and technical architecture documentation.
• Beta: distributable installation, mutual authentication, and effect isolation verified on clean infrastructure.
• General availability: deployment on client infrastructure, with backup, rollback, and documented operation.

We don't publish dates. Promoting a version depends on completing verifications, not on the calendar, and we'd rather say that than commit to a quarter.

What it isn't

• It's not a generic framework for AI applications.
• It's not a web console that runs tasks incidentally.
• It's not a data pipeline orchestrator with agents bolted on afterward.
• It doesn't replace the business software that consumes it.
• It doesn't promise exactly-once delivery of effects.

Architecture

The flow runs from the control plane to durable execution and back to reconciliation:

• Control plane: contracts, authentication, projects, agent squads, API, and auditing.
• Transactional admission: the request, its link to the engine, and the flow's startup are written in a single PostgreSQL transaction with an outbox pattern.
• Durable execution: self-hosted Temporal as the control authority, with workflow history, timers, signals, and deterministic replay.
• Control and effect activities: kept separate, with content-addressed storage for artifacts and projections.
• Effect isolation: a host-side executor manager, with a fail-closed policy.
• Verdict via typed reconciliation: a request's outcome isn't inferred from a process's exit code, but from an explicit reconciliation.

Connectors expose an HTTP API with a snapshot and event stream, and there's an SDK for Node, a command-line interface, and a web console. The current first-party drivers are Codex and Claude, governed through their CLIs.

Who uses it today

The first consumer is Lummiere, Coresis's hotel management platform, where it supports conversational booking operation. You can see the details in the Lummiere case.

AquilaMesh isn't the only way Coresis builds with AI. For product agents and flows we also work with Dify, as in Labbu, and with n8n for orchestration and integrations. The choice depends on the case, not on preference. You can see the full picture at our artificial intelligence agency in Colombia.

Why we built our own runtime

Because in projects where delegated work matters, the hard part isn't getting an agent to respond well once — it's making the operation auditable, retryable, and recoverable when something fails midway. That part isn't solved with a better prompt: it's solved with an execution model.

Frequently asked questions

Can I use AquilaMesh in my organization today?

It's in preview and runs on a Coresis-owned product. For an external organization, the current path is a technical conversation: we evaluate whether your case fits what the runtime already solves and, if it doesn't, we'll tell you. There's no public download or self-service.

Is it proprietary technology?

Yes. AquilaMesh is Coresis's own development and its code isn't public. It can be evaluated technically under agreement, with access to the architecture documentation and a demo of the runtime in operation.

What problem does it solve that an agent framework doesn't?

The focus isn't building agents, but operating delegated work with guarantees: receiving an intention formalized as a contract, compiling it into an explicit plan, running it with policies, approvals, and retries, and persisting state, events, and evidence. A framework solves the building part; AquilaMesh handles durable operation.

What does durable execution rely on?

On self-hosted Temporal as the durable control authority, with PostgreSQL for transactional admission of requests. That enables retries, timers, signals, and recovery through deterministic history replay.

Which models does it work with?

The current first-party drivers are Codex and Claude, governed through their CLIs. Local model support is on the roadmap.

What is Coresis's innovation lab?

It's the line of work where we build our own technology instead of waiting for the market to solve it. AquilaMesh is its most advanced project, but the criterion is the same across all of them: test it on our own products before proposing it to a client.