Senior Applied AI Engineer

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, hundreds of sources, resolved into a single record and served to humans and AI agents alike.

This role sits on a small senior team working on extraction and structuring at global scale. Turning messy, inconsistent records from many sources into accurate facts about 15M companies and 130M people. The accuracy bar is high and the cost bar is low, because both are measured per record and there are billions of them.

The Role

As an Applied AI Engineer on this team, you build the multi-step agent systems that bring new data in and turn raw records into structured, verifiable facts.

That means agents that plan across several steps, call tools, hold state, and stop for human approval before anything is committed. It also means the extraction underneath: getting reliable structured output from HTML, undocumented APIs, protocol banners and free text, where the target set is not known in advance and the source is under no obligation to be consistent.

This is a build role. You will prototype fast, then be the person who makes the prototype hold at volume.

Expect to invent. The published approaches to extraction and agent reliability were not written for this volume or this accuracy bar, and you will find where they stop short. Designing the replacement method, and proving it works, is the job rather than a side project.

What You'll Own

Multi-step agent systems

• Build agents that plan across many steps, call tools, hold state between them, and stop for human approval before anything is trusted

• Make every step observable and independently testable, with retries, idempotency and hard budgets on cost, latency and step count

• Handle partial failure properly. A run that dies two thirds of the way through a long job should not cost you the whole job

• Set the reliability bar for agents doing unattended work at volume, and own it when it slips

Extraction and structuring

• Get reliable structured output from HTML, PDF, undocumented JSON APIs, protocol banners and free text, using constrained decoding, JSON schema enforcement, function calling and Pydantic validation

• Extract against an open vocabulary, where the target set is not fixed in advance. Regex and fixed signature lists are the baseline to beat, not the approach

• Push accuracy on sources that are inconsistent, incomplete and occasionally hostile to being parsed

• Design new methods where the existing ones fall short, and produce the evaluation that proves the new one is better

Building the context graphs

• Own the path from extracted entities and relationships into the graph, mapping them onto the schema, removing duplicates, and carrying confidence through instead of dropping it at the boundary

• Have models propose schema-constrained changes rather than write freely, with provenance attached to every fact

• Build the review path, so a human can see the diff, judge the confidence, approve or roll it back, and trace what happened afterwards

• Keep lineage intact end to end, so any fact can be traced back to what produced it

Cost, scale and evaluation

• Keep the cost curve flat as volume grows. A method that works on a thousand records and falls over at a billion is not a method

• Decide where models earn their cost per record and where cheaper deterministic machinery does the job just as well

• Own evaluation for your layer. Golden sets and regression suites, LLM-as-judge where its failure modes are understood, and accuracy, cost and latency tracked per record

• Evaluate the whole trajectory on multi-step runs. A correct final answer reached by a broken path is a defect

What We're Looking For

Must Haves

• 5+ years of applied AI or ML engineering, with work that reached production and changed something

• Very large scale, not negotiable. You have run inference over billions of records and can talk through what actually broke: throughput ceilings, rate limits and backpressure, partial failure halfway through a long run, retries and idempotency, and what a tenth of a cent per record adds up to at full volume

• Proven multi-step agents in production : LangGraph or equivalent, tool use, state management across steps, retries, checkpointing for human approval, and a clear account of where they break

• Strong structured extraction from messy and complex inputs, with constrained decoding, schema enforcement and validation

• Experience having a model write into a structured store , with the guardrails that requires: schema-constrained proposals, provenance, human-reviewable diffs, rollback

• Expert Python , typed and production-standard, plus SQL against Snowflake or similar

• Distributed processing at volume: Spark or Ray , with partitioning, batching 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

• Evaluation as part of the build , not an afterthought. You can show the harness, not just the metric

• Ontology and schema design , so new sources attach without a migration each time

• Fluency across the main model platforms and open-source models: Anthropic, Bedrock, Vertex, Fireworks, Together, OpenRouter or equivalents, plus open weights where they are cheaper for the job. Prompt caching, batch inference, and model selection driven by cost and latency rather than habit

• Tracing and observability on multi-step runs: LangFuse, LangSmith, Pydantic Logfire, OpenTelemetry or similar

• Tiered processing design: cheap deterministic methods first, model inference only where it earns its place, with the numbers to show what each tier costs and recovers

• A builder's instinct: whiteboard to working prototype to production without waiting for a roadmap

• 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

• 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.

Highly Valued

• Large web crawls, DNS records, TLS certificates, banners, CPE or protocol data

• Generating rules or code that a deterministic engine consumes, rather than model calls at runtime

• Self-hosted inference: Hugging Face, PyTorch, sentence-transformers, ONNX, vLLM

• Fine-tuning, distillation or quantisation where it lowers cost, with a clear view of when the operational weight is not worth it

• Building context or knowledge graph ingestion systems : turning extracted entities and relationships into nodes and edges, with schema mapping, deduplication and confidence carried through the pipeline. Neo4j, Memgraph or similar

• Publications, patents or open-source contributions in extraction, retrieval or agents

• 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

Open to AI-native development; we are 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

• Hard problems with no packaged answer. Accurate extraction from adversarial sources, and agents you can trust to write into a production store, are open problems. You will be defining the method

• 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

• Scale is the hard part. Billions of records. The interesting failures only show up at volume

• Your work multiplies. Everything you automate is work nobody has to do by hand again

• One of the largest proprietary business datasets in the world to experiment on

• Small senior team, no layers, fast decisions

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