Firmable is the market-leading B2B sales intelligence platform in Asia Pacific, backed by leading investors, growing 2,000+ customers strong and growing in the US. We build one of the richest datasets about businesses anywhere: who they are, who works there, and what is changing. Millions of companies, thousands of sources, resolved into a single company and served to humans and AI agents alike.

This role leads a small senior team working on entity resolution and graph engineering at global scale. Binding conflicting records from many sources to one real business, across 15M companies and 130M people, then making data available for agentic use cases. The volume is unforgiving. Methods that hold at a million records do not survive here, and most of the interesting failures only appear at full scale.

The Role

As Applied AI Engineering Lead, you own the systems that resolve business data at scale and serve it to the humans and AI agents that act on it.

You will lead a small, senior team, starting with few engineers and growing from there. The work spans extraction and structuring from difficult sources, entity resolution and graph engineering underneath it, and retrieval that keeps cost and latency inside a budget as volume grows.

This role is ~80% hands-on engineering, ~20% team lead and cross-functional collaboration. If you are looking to move into pure management, this is not it. If you want to work on genuinely hard engineering problems at a scale very few companies operate at, and have the influence to shape the architecture, this is your role.

Expect to invent. Parts of this do not exist in a library, a paper or a vendor product. You will read the research, find where it stops short, design the method yourself, and prove it holds at a volume where approximately right is not good enough. Some of that work will be incremental. Some of it will be closer to a fundamental breakthrough, and you will be the person accountable for whether it works.

What You'll Own

System architecture

• Own the architecture end to end, from raw source through resolution and storage to the interfaces agents and customers call

• Set the boundaries between layers and hold them as the system grows and the team scales

• Sequence the build: which source, which layer, which capability, and what gets deferred

• Invent where you have to. Recognise when the published approaches will not hold at our volume, design the replacement, and put the evidence behind it

• Make the calls where no established answer exists, and write down why

Multi-step agentic systems

• Design agent systems that both write to and read from a persistent store, not single-turn extraction

• Separate planning from execution, and prefer state machines to free-running loops so a run can be replayed deterministically and paused for human approval

• Orchestration in LangGraph, Temporal or equivalent, with idempotency, compensation and partial-failure handling as first-class concerns

• Trace and evaluate multi-step runs, attributing cost and latency to each step, and score the whole trajectory rather than only the final answer

Agentic retrieval and dynamic context

• Break a question into parts, plan the traversal, expand context as results come back, rerank what matters, and stop before the agent burns through its budget

• Decide per query what slice of the graph enters the context window, compress it, and keep the source trail attached so every answer can show its work

• Work out what replaces naive RAG for short, entity-rich records, where vector similarity over a flat corpus does not hold up

• Treat token economics as a design constraint. Know what an answer costs, where caching earns its keep, and when a model has no business being in the loop

Team and technical direction

• Hire, lead and mentor a small senior team spanning multiple countries; set the technical bar and how the team operates day to day

• Work closely with other teams building Firmable platform modules

• Partner with Product to take early-stage ideas to architecture decisions and working prototypes, fast

• Set the standard for evaluation, observability and testing. There is no QA function behind this team

What We're Looking For

Must Haves

• 8+ years building production data or AI systems, including at least one you architected from scratch and then operated

• Very large scale data architecture design and delivery. You have designed and run systems processing billions of records, and can talk through what actually broke: skew, memory, shuffle cost, retries, backfills, and what a full reprocess costs in both hours and dollars

• Depth in two of the following and working knowledge of the rest: record linkage at scale, property graph modelling, hybrid retrieval, multi-step agent systems

• Production experience with agent systems that write to and read from a persistent store, including the guardrails that requires: schema-constrained writes, provenance, human-reviewable diffs, rollback

• Agentic retrieval experience: traversal planning, iterative context assembly, stopping rules, cost caps. You know why naive RAG underperforms on entity-rich data

• Strong Python: typed, async, Pydantic for schema enforcement, FastAPI or equivalent for service boundaries

• Distributed processing at that volume: Spark, Snowpark, Ray or Dask, with partitioning, skew handling and incremental processing chosen deliberately rather than by default. You know why a job that runs in an hour on a sample takes three days at full volume

• Property graph modelling in Neo4j, Memgraph or similar: Cypher, traversal cost, supernode handling, and the judgement of when a graph beats a join

• AWS in depth: S3, Lambda, ECS or EKS, Step Functions, IAM, with Terraform or CDK

• You build the evaluation before the feature. Where no benchmark exists, you define one and hold the team to it

• You have invented a method, not just applied one. A technique you designed because the published approaches did not hold, with the evaluation that showed yours did

• Exceptional cross-functional communication: comfortable presenting to exec stakeholders and debugging a resolution mismatch the same afternoon

• You operate with a fully AI-native development workflow: agentic coding, AI-driven test generation and automated review pipelines are your default, not your experiment. In 2026, this is table stakes at Firmable

Highly Valued

• Serving design for machine consumers: query planning across heterogeneous stores, caching, per-tenant scoping, metering, rate limiting, MCP as a delivery surface

• Built a platform other engineers shipped products on, with versioning and backwards compatibility as real constraints

• Warehouse and search internals, not just query syntax: Snowflake clustering keys, micro-partition pruning, warehouse sizing and credit cost per query

• OpenSearch or Elasticsearch mapping design, analysers, BM25 tuning, kNN and hybrid retrieval

• dbt, Airflow, Dagster or Temporal for orchestration and lineage

• Company data, KYB, credit or master data management

• You have run a system where a wrong answer carried a commercial or regulatory cost

• Startup or high-growth scaleup, where you shipped fast and owned outcomes end to end

How We Build

AI-Native, Not AI-Assisted

Firmable is built on an AI-native engineering philosophy, and we mean that literally. We don't use AI as a productivity tool bolted onto traditional workflows. AI is the workflow. Every engineer at Firmable is expected to operate with fully agentic development, testing, and review pipelines as their default mode of working.

This means:

• Agentic development: features are designed, scaffolded, and iterated with AI agents doing the heavy lifting — you direct, review, and elevate

• AI-powered test generation: test coverage is driven by AI agents that understand context, not manual test-writing as an afterthought

• Automated code review: AI-assisted review pipelines flag issues, suggest improvements, and maintain standards before humans ever look at a PR

• Continuous AI feedback loops: traces, evals, and observability are built in from day one, not retrofitted later

If you're not already working this way, this role will require a rapid and genuine mindset shift. We're not looking for people who are open to AI-native development; we're looking for people who already live it.

The Operating Environment

Firmable runs lean and ships fast, intentionally small teams, no layers, minimal process, and a weekly release cadence moving toward daily. Teams own their stack end to end: you design it, you build it, you ship it, you run it.

This is a startup-to-scaleup environment and it comes with real expectations. There are no fixed hours. The pace is high, the team is always building, and when something matters it gets done. In return, you get genuine ownership, a seat at the table on every major architecture decision, and the opportunity to build something that doesn't exist anywhere else in the market.

Why This Role

• Genuinely hard problems. Entity resolution, graph engineering and agentic retrieval at this volume are unsolved in the general case, and the design decisions are yours to make

• Research-grade problems, production constraints. Some of this needs new methodology and occasionally a fundamental breakthrough, done against real data and a real deadline rather than in a lab

• Global scale. 15M companies, 130M people, billions of records. Methods that work on a million rows fail here, and finding out where is part of the job

• You lead the function, not a squad inside it. One system, one team, and a direct line to every architecture decision

• Greenfield. Most of this stack is unbuilt

• Competitive base and meaningful equity. We balance strong compensation with a share in the upside we are building toward

Firmable is an equal opportunity employer. We believe diverse teams build better products.