MoFlux helps platform teams coordinate shared LLM capacity, reject unsafe work before it reaches providers, and explain every admission decision. Today, Latchflo distributes expiring capacity grants and Tyr enforces concurrency and in-flight token admission limits locally—without putting the control plane on every request.
LLM requests vary dramatically in size and duration. When capacity is managed independently by each replica—or hidden behind growing queues—the result can be degraded latency, provider pressure, retry amplification, and incidents that are difficult to explain.
Large or concurrent LLM calls can exhaust downstream capacity, increase tail latency, and spread instability across dependent services.
Tyr evaluates concurrency and estimated in-flight token demand before the provider call begins, then admits, queues within a configured bound, observes, or rejects the work.
A safe limit on one gateway can become unsafe when dozens of replicas independently apply the same ceiling.
Latchflo partitions a fleet-wide capacity pool into bounded, expiring per-agent grants, while Tyr enforces only the capacity assigned to its local process.
Unbounded waiting turns capacity pressure into timeouts, retry storms, memory growth, and unpredictable user experience.
MoFlux is admission-first. Tyr can fail fast by default or permit only a deliberately bounded queue, keeping overload visible instead of silently accumulating work.
Changing concurrency, queue, and token settings independently can leave replicas in inconsistent or unsafe intermediate states.
Tyr applies complete, versioned limit snapshots atomically and rejects stale revisions. Latchflo records controller epochs, grant revisions, acknowledgements, and lease expiration.
Without decision context, platform teams struggle to tune policies, respond to incidents, or prove which configuration governed a request.
Tyr exposes admission mode, decision reason, limit revision, admission identity, and—when managed by Latchflo—the grant ID and controller epoch tied to the decision.
If every provider call requires a remote policy lookup, control-plane latency or downtime can directly affect application availability.
Latchflo remains off the live request path. Tyr uses locally installed grants and continues making admission decisions until that authority expires, then fails closed.
Instead of allowing every replica to discover overload independently, MoFlux separates fleet coordination from local execution and makes the resulting decisions visible.
Reject or observe work before it consumes scarce provider-facing concurrency and in-flight token capacity.
Partition global limits across active Tyr agents instead of multiplying the same ceiling across every replica.
Use observe mode to measure prospective rejections before enabling enforcement for production traffic.
Route only selected Anthropic or OpenAI traffic through Tyr while retaining existing ingress, auth, networking, and secrets.
MoFlux is designed to make capacity policy operationally useful across engineering, reliability, product, and governance functions.
One capacity authority for a fleet of local gateways without a per-request control-plane round trip.
Explicit rejection reasons, bounded admission behavior, health endpoints, live statistics, and grant-level provenance.
A measured path from observe mode to enforcement without changing provider request formats or surrendering credential ownership.
Versioned policy application and an auditable control trail today, with stronger enterprise identity and access controls on the roadmap.
Latchflo and Tyr solve different parts of the same enterprise problem: coordinate shared capacity centrally, but keep request-path admission fast and local.
Control plane
Latchflo owns the fleet-wide capacity view. It registers Tyr agents, allocates equal shares from configured pools, issues versioned expiring grants, receives heartbeats and acknowledgements, and preserves a durable audit trail.
Data plane
Tyr is the admission-first runtime gateway. It estimates request demand, evaluates the local versioned limit snapshot, and either proxies, observes, queues within a bound, or rejects the provider call before scarce capacity is consumed.
Tyr uses a token-aware admission engine with immutable reservation previews, admission-linearized revisions, observe mode, adaptive estimation, stable admission IDs, usage reporting, and bounded drain behavior.
The control path distributes authority; the request path consumes it locally. Latchflo does not participate in every LLM call, and an expired grant causes the local agent to stop new admissions.
Controller epochs, pool revisions, agent records, grants, ACKs, and audit events survive process restart in SQLite.
Tyr applies complete snapshots atomically and fails closed at lease expiration rather than operating indefinitely on stale authority.
Admission remains a local runtime decision, avoiding a new synchronous control-plane dependency in the provider request path.
A practical enterprise deployment keeps existing ingress, application auth, service networking, provider credentials, and observability. Only selected outbound LLM traffic is routed through Tyr, while Latchflo coordinates the gateway fleet outside the request path.
Tyr's observe mode runs the same reservation and capacity decision while allowing would-be capacity rejections to continue upstream. Teams can quantify policy impact before enforcement and expand scope incrementally.
Start with one LLM-backed service, provider route, model group, or non-critical environment rather than changing the entire estate.
Keep provider-shaped request bodies and existing credentials. Route Anthropic Messages or OpenAI Chat Completions through Tyr.
Run the real reservation and admission logic without blocking capacity-related requests, then tune limits against actual workload behavior.
Turn on fail-fast or bounded-queue admission after the policy is validated, while monitoring rejection reasons and pool pressure.
Register Tyr agents and distribute versioned, expiring grants from a central capacity pool outside the request path.
The present system demonstrates the distributed capacity model, but several controls expected in a mature enterprise platform remain roadmap work. The website distinguishes those boundaries directly.
Latchflo currently runs as a single-controller prototype with SQLite. Multi-controller coordination and PostgreSQL are roadmap work.
Today's token budgets limit concurrent in-flight exposure. They are not monthly spend caps, provider invoices, or billing-grade token accounting.
Tyr currently supports Anthropic Messages and OpenAI Chat Completions shapes and does not translate between provider formats.
The prototype uses bearer-token administration and agent credentials. OIDC, RBAC, workload-attested mTLS, and policy governance are future capabilities.
The current column reflects the uploaded implementations. Near-term and longer-term columns describe intended production evolution, not shipped capability.
MoFlux is built around a clear enterprise operating model: define fleet capacity centrally, enforce admission locally, preserve request-path independence, and make every policy revision and decision attributable.