Luxury Retail, Run on an AI-Native Platform

Every retailer says it is becoming a technology company. Factory 54 is doing something more specific: carving out F54 AI Labs, a venture with a mandate to apply AI across a business that runs boutiques, e-commerce and airport duty free for dozens of global luxury brands. Our engagement is the platform side of that mandate. Before the venture ships its first model, somebody has to make the infrastructure underneath it boring, observable and safe, and that somebody is the DevOps team we are building and leading.

The interesting part is that this is not a greenfield. The AI initiative lands on top of a real, revenue-carrying estate with fifteen years of history, and the platform work splits cleanly in two: make the existing estate AI-ready, and build the new AI infrastructure the venture needs from day one.

The estate the venture lands on

Like most retailers with real history, Factory 54's landscape grew by necessity, and it is genuinely hybrid.

• On-prem IIS carries the .NET transactional core, the systems that take orders and money.
• Hetzner runs a second IIS pool, a deliberate cost arbitrage that only pays off if workload placement keeps being re-evaluated.
• AWS hosts multi-region workloads, with Azure carrying the data platform and Cloudflare holding the edge, where WAF and bot rules guard limited drops from scalper fleets.
• Datadog and GitHub Actions tie the whole thing together: observability on one side, delivery on the other.

Context for any incident lives in five places at once. When checkout latency spikes at two in the morning, the on-call engineer spends the first fifteen minutes just assembling the picture, and in luxury retail those minutes are measured in lost orders, not in dashboards.

The brief

F54 AI Labs needs what every serious AI venture needs and almost none build first: a platform that treats models, prompts and agents as production software. Our ownership covers the DevOps team itself, the delivery pipelines, the runtime estate, and the AI infrastructure layer, with three commitments shaping everything below.

• Verification over trust: no agent output reaches production on a model's confidence. Tests, empty Terraform plans and eval suites decide, not vibes.
• Guardrails at the platform level: read-only roles, branch protection and PR-only automation are enforced by IAM and GitHub, not by prompts.
• Compliance by construction: Israel's Amendment 13 privacy reform and GDPR for the European operation are gateway concerns, addressed before six teams have shipped, not after.

Gateway before models

The first thing the AI platform gets is not a model. It is a front door. Every application calls one internal endpoint instead of calling providers directly, and that endpoint carries the whole operational contract: routing and fallback between providers, cost attribution per team and feature, rate limits so one runaway loop cannot exhaust throughput during a drop, PII redaction at the boundary, and a full audit log of every prompt and completion.

Beside it sits the discipline that makes AI features maintainable at all: evaluations as CI gates. Every AI feature owns a golden dataset curated with the business, and every prompt change, model swap or silent provider update runs the suite in GitHub Actions. Deterministic checks first, an LLM judge calibrated against human ratings second, and a regression fails the build exactly like a failing unit test.

Agents on the platform we own

With the front door in place, AI starts paying rent inside the platform team itself. The flagship is incident triage. An agent with strictly read-only access to Datadog, CloudWatch, the GitHub deployment API and the Hetzner surface fires on page, assembles the cross-cloud picture and posts a correlation narrative with ranked hypotheses before the human has opened a laptop. It proposes. The human decides. Every tool call is logged.

Press Page on-call below to replay a night we expect to have often, and watch the agent work an incident the way a good SRE does, just ninety seconds faster.

Behind the flagship sit the quieter agents, each with the same shape: propose in a pull request, verify with something objective, never merge themselves.

• .NET modernisation: characterisation tests are generated and approved before an agent migrates a single project off .NET Framework, so the suite decides whether the agent was right, one PR per project, strangler-fig routing in front.
• Brownfield Terraform: import plus agent refactor, accepted only when the plan comes back empty. An empty diff is the one code review a model cannot argue with.
• WAF tuning: deterministic clustering of blocked traffic, an LLM writing the interpretation, and every rule change shipped as a Terraform PR in count mode first, because a false positive on a luxury checkout is a lost order.
• Alert hygiene: months of monitor history correlated against what anyone actually did, and the noise retired by reviewed PR, so a page means something again.

Where the platform reaches the shop floor

None of this exists for its own sake. The venture's commercial workloads all land on the same rails: a catalogue normalisation pipeline that maps every brand feed into a controlled vocabulary it is not allowed to invent entries for, Hebrew product copy generated under per-brand voice rules with a merchandising approval queue, and retrieval infrastructure where freshness is the hard part, because a beautiful semantic search result pointing at a sold-out item is worse than no feature at all.

Each of those ships with its eval suite in CI and its costs attributed through the gateway. That is what AI-native means here: not more models, but models that arrive with the same discipline as any other production dependency.

How the engagement runs

We lead the DevOps team as owners, not visitors: hiring into it, setting the on-call standard we would want to hold ourselves, and building the platform in the open, documented as it grows. The sequencing is deliberate. Gateway and evals first, the triage agent second, the modernisation and IaC agents behind them, and the commerce pipelines as the venture's features come online.

The measure of success is the same one we hold every platform to: deploys that are boring, pages that are real, costs that are attributed, and an AI estate where the answer to "can we trust it in production" is a test suite, not a promise.