About ai71

ai71 builds enterprise-grade AI for the organisations that underpin the real economy: governments, banks, and large enterprises. We're rooted in the Middle East and Africa, where the demands on us are at their highest: sovereignty, on-prem, multi-lingual, and real regulatory weight. Those same demands are arriving everywhere, and what holds up here travels. Our work is grounded in a commitment to deploying AI securely, responsibly, and at scale.

Our flagship product is Ask, our agentic AI platform. It puts AI agents to work on an organisation's own knowledge, systems, and workflows: agents that reason through complexity, draw on the organisation's collective knowledge, and complete real work rather than just answer questions. Ask is infrastructure agnostic and model agnostic, so it runs inside a customer's existing stack and security perimeter, or in sovereign clouds, instead of forcing them onto ours. Today it's deployed across knowledge-heavy functions (legal, finance, HR, procurement) in some of the most regulated environments in the world.

Role overview

We build Ask in squads: roughly a PM, three or four engineers, and a designer, each owning a slice of the product end-to-end and shipping it. A squad is small enough that the PM stays genuinely close to the work and carries real accountability for the quality of what ships.

We're hiring product managers for three kinds of ownership, and we're open on which one fits you:

Own a squad. Take one slice of the platform and make it excellent. You'll set the direction, write the PRDs, make the calls, and answer for the outcome.

Own a new bet. Some of the most valuable things we could build don't exist yet, and won't come from the current roadmap. This is 0→1 work: find the problem worth solving, prove it's real, and build the thing.

Go forward deployed. This is the sharpest end of the product. You sit with the customer, inside the ministry or the bank, and you turn the platform into something that works for them specifically. You see what actually holds up in production long before anyone else does, and the rest of the roadmap is downstream of what you learn. If you want the shortest possible distance between a decision you make and a real operation it changes, this is it.

We're hiring the person before the squad. We'll place you where your strengths meet our gaps, and we'll be straight with you about which gap that is during the process. The shape of the org will keep moving as the product does, and you should expect that.

This is deliberately not a role for someone who wants the strategy settled first. Ask runs inside air-gapped government networks, over messy multi-lingual corpora, for procurement-driven buyers betting real operations on us. A meaningful part of the job is deciding what's true, not executing against something already decided. The hardest questions on this platform are open right now, and whoever takes this role gets a real say in how they close.

What you'll do

Build things yourself. Prototype it, query it, script it. We expect PMs here to be genuinely dangerous with an AI coding agent, whichever one you like, and to bring a working artefact to an argument rather than a deck. The fastest way to settle a product debate here is usually to build the thing and look at it.

Own the outcome, end-to-end. Discovery, PRDs, prioritisation, shipping, and the metric it moves. Nobody here will hand you a spec, and nobody will thank you for delivering the wrong thing on time.

Own evals. This is one of the hardest and most important problems on the platform. Agent quality is not obvious from a demo, and "it looked fine when I tried it" is not a quality bar for a system running a ministry's legal review. You'll define what good means for your surface, build the test sets and the judges that measure it, and wire them into how the squad ships, so we know whether an agent works before a customer finds out it doesn't.

Stay ahead of the industry, and know what to build. This field moves faster than any roadmap. Capabilities we scope one quarter can ship free in an open-source release before we finish them, model releases reset what's possible every few weeks, and standards like MCP go from novelty to expected in months. Knowing what to build, what to wrap, and what to adopt outright is one of the most consequential calls you'll make, and it's a call you'll make repeatedly. That means knowing the landscape properly: the open agent frameworks, the observability and eval tooling, what the frontier labs shipped last week and what it means for us. We'd rather integrate something excellent than spend two quarters rebuilding it, and we'd rather build something ourselves than depend on a layer where our customers' requirements are unusual. Telling those apart is the skill.

Ship into constraints most PMs never see. On-prem and air-gapped, sovereign cloud, model agnostic, multi-lingual, security-cleared environments. Every one of these is the default case here, and they shape the product from the first design decision onwards.

Work across squads, not just inside yours. We plan in cross-squad pushes framed around customer benefit, and no squad owns one alone. Your squad contributes two or three things to a push, and you make them land together with people who don't report to you.

Stay close to the people using it. Government and enterprise buyers, in the room, through long procurement cycles. Our forward-deployed team is your fastest route to the truth, so use them, and give them something back.

The team

Ask is around 60 engineers, five PMs, a PMM, and three product designers. You'll report to the Head of Product and work daily with Engineering, Design, Deployments, and Commercial. The team comes from tier-1 product companies (DeepMind, Google, Amazon, Apple) and tier-1 strategy firms including McKinsey QuantumBlack and BCG X.

How we work

Low ego, high curiosity. The best ideas win here, not the loudest voices. We approach problems with humility, ask better questions, and stay genuinely open to being wrong. That's how a small team learns fast enough to stay ahead of a field that resets every few weeks, and it's why you'll change your mind in the open here and be respected for it.

We work in the open. Decisions and discussion happen on shared channels rather than in DMs, so the whole team can learn from them, and so can the AI agents we build on top of them.

Who you are

You bring 5+ years in product with a genuinely technical background: a CS or engineering degree, or real time as a software, data, or ML engineer. You can hold your own in an architecture conversation and you're expected to. You've shipped ML or LLM-powered products and understand how they fail: hallucination, drift, latency, cost, prompt injection. You've had to make a probabilistic system trustworthy for someone who never wanted probability in the first place. You're comfortable with data: SQL, instrumentation, reading an experiment result without waiting for someone to interpret it for you. Experience with enterprise, regulated, or public-sector buyers is a plus, as is Arabic language ability, agent and RAG evaluation, or time in a forward-deployed model.

Beyond experience, here's what we look for:

Builder: You have a keen sense of ownership and can point to things that wouldn't exist without you. Founded something, or were employee number small, or took a product 0→1 to real users. We found this to be a good proxy for initiative, self-direction, and comfort when the plan is still forming. Side projects count too, particularly the ones you kept going long after the first weekend.

Technical instinct: Faced with an unfamiliar problem, your first move is to open a terminal and go find out. You use AI coding agents daily and you enjoy it. It's simply how you work.

Product judgement: You can tell the difference between what's hard and what merely looks hard, and you'd rather ship one thing that compounds than five that don't.

Spine: You can hold a position with an engineer, a customer, and an exec, and change it the moment you're shown you're wrong.

Clarity: You connect the dots others miss, and you turn an ambiguous problem into something a squad can actually build against.