F
Fournex

About Fournex

A production-grade runtime for reinforcement learning agents

Fournex is the layer where trained RL policies are loaded, executed, and managed as living systems, not just called like static models.

Fournex is not a dashboard or an experiment tool.

It is an execution engine.

What Problem It Solves

Most RL teams can train agents, but once training is done they have no solid way to:

  • Run agents continuously in real systems
  • Maintain state across steps and episodes
  • Serve policies reliably under load
  • Debug what actually happened in production
  • Integrate agents cleanly into robotics, simulation, or service backends

They end up building fragile custom runtimes.

Fournex replaces those one-off runtimes with a standard, high-performance agent execution layer.

What "Runtime" Actually Means

A runtime is responsible for the hard stuff around execution:

  • Policy execution: load policy artifact (SB3, TorchScript, ONNX), run inference
  • Stateful sessions: maintain per-agent state (RNN hidden state, filters, normalization stats, last obs/action, episode context)
  • Environment loop support: optionally run step loops server-side (agent ↔ env) with consistent timing
  • Determinism & replay: capture what happened and reproduce it (seed, version, config, obs/actions/rewards)
  • Performance: low overhead per step, batching, efficient memory layout, pinned cores, etc.
  • Isolation: crashes or bad policies shouldn't take down the node; resource caps and timeouts
  • Observability: metrics, traces, logs; minimal but essential signals
  • Integration surface: stable API/SDK that robotics / sims / games can embed against

Two Modes of Runtime

Stateless Inference

action = policy(obs)

For low-latency calls from external systems.

Stateful Agent Sessions

session.step(obs) → action

Maintains continuity and supports control loops, RNNs, etc.

Our Product Vision

"The best session engine + policy runner you can embed or deploy."

Why Teams Adopt This

Teams don't adopt runtimes because they love infra—they adopt because it immediately solves:

"We can't run this policy reliably at 50–200Hz."

"We need deterministic replay for debugging."

"We need RNN state / episode continuity."

"We need to deploy 5 versions and compare."

"Our inference loop overhead is killing us."

Fournex nails stability, determinism, and ease of integration more than dashboards.

What Fournex Does

✓Package a policy
✓Run it locally and in Docker
✓Call it via API or SDK
✓Use stateful sessions
✓Capture traces for replay/debugging
✓Run it fast and reliably under sustained load

That's the smallest "runtime" that feels real.