We are looking for an excellent AI Backend Engineer to join one of Sweden's fastest growing start-ups which is backed by Nvidia, Microsoft and AWS. The company also operates under the Inspection for Strategic Products.

Location: Fully remote within India. From 2027 you join our Bangalore office as part of the founding local team

Employment: Full-time, permanent

Start: As soon as you are available

About the job

Antrino Labs is building the platform that makes every square meter intelligent.

The physical world runs on processes nobody can actually see. Goods move, people queue, machines idle, space goes unused, and the decisions made about all of it are based on samples, guesses, and reports written after the fact. Software solved this for the digital world twenty years ago. Everything online is measured, understood, and acted on in real time. The physical world is still dark.

We are building the execution layer that closes that gap. Antrino lets any organization deploy vision intelligence into a physical space and get back what is actually happening there — as structured, queryable, real-time information rather than footage. Not a research project, not a custom integration, not a team of ML engineers. A platform, where you describe what matters to you and deploy it.

What people build on it is broader than what we designed for. Operators use it to understand processes, find where time and space are being wasted, measure flow and utilization, catch problems while they are still happening, and turn all of it into data good enough to act on.

Everything is built on Privacy by Design. Data protection and GDPR compliance are part of the architecture, not a layer added afterwards.

We recently closed our Seed round, announced together with Dagens Industri, and we are scaling to meet demand. Antrino Labs is also registered with Inspektionen för strategiska produkter (ISP), the Swedish authority for strategic and dual-use products.

The role

We are hiring an experienced AI Backend Engineer to build the services that turn a customer's intent into working intelligence.

This is distinct from our MLOps and DevOps roles, and it is worth being precise about the difference. MLOps owns whether a model runs well in production, and DevOps owns the infrastructure everything runs on.

You own the layer in between: the backend logic that lets a customer describe what they want detected, compiles that into a real execution plan, routes it across our detection backends and model APIs, and turns raw model output into something structured, explainable, and actionable. If MLOps is about models running fast and DevOps is about the ground they run on, you are building the reasoning and orchestration that sits on top of both.

Concretely, when a customer builds something in Studio, our composition canvas, that graph has to become a running system: a plan that decides which models to call, in what order, gated by cost and confidence, producing events and evidence that a customer can trust.



You will work on the compiler that turns a graph into an execution plan, the runtime that executes it, and the backend services — written in Python and TypeScript — that detection, classification, and measurement actually run through. You will also work on our Agent, which interviews customers, proposes and edits these graphs, and deploys them with confirmation.

Getting an LLM to reliably manipulate a structured graph, validate it, and explain its own reasoning is a real engineering problem, not a prompting exercise.

You will work closely with the team building our first-party detection models and with the product engineers building the interfaces customers use, but this role sits between them: it is backend systems engineering for a product whose core logic is built out of AI calls.

Your main areas of responsibility will include:

- Building and maintaining the backend services that power our detection, classification, and measurement capabilities, largely in Python with FastAPI
- Working on the compiler that turns a customer's Studio graph into a runnable execution plan, and the runtime that deploys and executes it
- Designing the routing logic that decides which model handles a given piece of work, including the cost-gating architecture where a cheap model decides when an expensive one is allowed to run
- Building and extending our Agent — the interview, graph-editing, and deployment-confirmation flows that let a customer describe intent in natural language and get a working pipeline
- Integrating and extending our first-party detection models, and calling out to frontier model APIs only where they do something ours doesn't yet, behind one clean interface
- Turning raw model output into structured, auditable events and evidence — the difference between a score and something an operator can act on and trust
- Designing APIs and data models for streams, behaviors, runs, and events, in PostgreSQL through Supabase with row-level security
- Working with real-time video pipelines, including how ingestion and stream state feed into what gets processed and when
- Writing tests and evaluation harnesses for logic that includes non-deterministic model calls, where "does this still work" is a harder question than a normal unit test answers
- Debugging production issues that span a customer's request, our orchestration logic, and the model call underneath it
- Participating in architecture discussions and code review, and helping define how this layer of the system should be built as it scales

Our stack

You do not need experience with all of this,



but you should recognize most of it and be able to argue about it.

- Backend: Python, FastAPI, TypeScript, Node.js
- AI: Our own first-party detection models, backed by Anthropic and Google model APIs where a frontier model is the right tool, plus structured tool-use and function-calling patterns
- Data: PostgreSQL through Supabase, with row-level security
- Streaming: RTSP ingestion, RTSP→HLS conversion, live and archive pipelines
- Frontend, for context: Next.js (App Router), React, TypeScript, Tailwind, shadcn/ui
- Infrastructure: Azure, GitHub Actions, on-site compute reached over Tailscale

Who we are looking for

- Substantial backend engineering experience on production systems, ideally including systems where an LLM or ML model was part of the core logic rather than a bolted-on feature
- Strong Python, and comfort in TypeScript or Node.js — you will work across both
- Real experience designing APIs, data models, and service boundaries, including PostgreSQL
- Experience building with LLM APIs beyond a simple chat wrapper: tool use, structured output, agentic flows, or systems that call a model as one step in a larger pipeline
- A working understanding of how to test and validate systems with non-deterministic components
- Experience with real-time or streaming data is a strong advantage
- You can reason about a graph or compiler-shaped problem, even if you have not built a compiler before
- You make decisions with incomplete information, take responsibility for the outcome, and say so clearly when something you built was wrong
- You work well asynchronously across time zones, write clearly, and raise problems early
- Excellent written and spoken English

What we offer

- Competitive salary, benchmarked to the top of the Indian market for this level and discussed openly early in the process
- Fully remote within India, with genuine ownership rather than delegated tickets — and a seat in the founding group of our Bangalore office from 2027
- Hardware of your choice and a budget for whatever else you need to work well
- Direct access to founders, to the Stockholm engineering team, and to customers
- Travel to Stockholm to work with the team in person

Process

We review applications continuously and contact candidates we think are a valuable match.

1. An introductory conversation about your background and the role
2. A technical conversation — we discuss systems you have built and how you made the decisions you made. No whiteboard algorithm puzzles
3. A working session with the engineering team on a real problem from our stack
4. A conversation with the founders about ownership, options, and terms

References may be requested in the final stage. We aim to keep the process short and to respect your time.

Apply with your CV and, if you have one, a link to something you have built. A repository, a shipped product, or a short note about a system you are proud of tells us more than a cover letter.

📌 AI Backend Engineer (Bengaluru)
🏢 Antrino Labs
📍 Bengaluru