New opportunity

AI Engineer

Centh AI · New York, United States

About this role

Centh AI is hiring an AI Engineer to build the agent platform for its healthcare staffing product. Working directly with the founder and early customers, the engineer will own substantial parts of the architecture, ship production systems, and develop workflows that help recruiters hire faster and make better matches. This is a full-time role listed in New York, NY.

Responsibilities

Design and implement core services and APIs for jobs, candidates, assignments, and agent runs.
Build integrations with applicant tracking systems (ATS), including authentication, data synchronization, webhooks or polling, error handling, and resilience.
Develop recruiter-facing views for sourcing boards, shortlists, screening results, and submissions.
Use LLMs and tools to generate role-specific questions, conduct structured screens, and draft candidate profiles or submissions.
Add logging, monitoring, and alerting to make agent behavior reliable and debuggable. Work with the founder and AI Strategist on technical designs, and use feedback from customer calls and demos to improve the product.

Requirements

Strong software engineering fundamentals and experience building web or backend systems, including taking projects from idea to working production software.
Comfort with APIs and integrations, plus hands-on experience with LLMs or agents or meaningful self-directed projects in the area.
An emphasis on impact, reliability, and maintainability; clear written and verbal communication; and comfort working with recruiters or operations leaders on a small team with changing priorities.
Experience with staffing, recruiting, or ATS/CRM systems is a plus, not a requirement.

To apply, email a resume or portfolio and brief introduction to jobs@centh.ai, including the role title in the subject.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

AI agentsLarge language modelsBackend developmentWeb developmentAPI developmentSystems integrationATS integrationsAuthenticationData synchronizationWebhooksPollingError handlingUI developmentLoggingMonitoringAlertingTechnical designRecruiting workflowsCommunication

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Own production architecture and core services
The role owns substantial parts of the architecture and calls for services and APIs covering jobs, candidates, assignments, and agent runs. Production delivery—not just prototypes—is an explicit expectation.
Make ATS integrations resilient
The engineer will build and own ATS integrations, including authentication, data synchronization, webhooks or polling, error handling, and resilience.
Build useful recruiter workflows
The role includes recruiter-facing sourcing boards, shortlists, screening results, and submissions. Customer calls and demos are intended to inform quick product iterations.
Turn LLM capabilities into structured work
The advertised work uses LLMs and tools to generate role-specific questions, run structured screens, and draft candidate profiles or submissions.
Make agent behavior observable and maintainable
Logging, monitoring, and alerting are explicit duties so agent behavior can be trusted and debugged. The role also emphasizes reliability, maintainability, and clear collaboration with the founder, AI Strategist, and non-engineers.

Likely challenges to think through

Keeping external data in sync
Preparation hypothesis: ATS authentication, sync, and webhooks or polling may create a trade-off between timely updates and resilient handling of missed or duplicate events. Prepare to explain a design for retries, idempotency, reconciliation, and visible errors.
Balancing agent usefulness with reviewability
Preparation hypothesis: role-specific screens and drafted submissions may need to be fast and useful while remaining understandable to recruiters. Prepare to discuss structured outputs, ways to inspect agent actions, and where a recruiter could review results.
Shipping quickly without accumulating brittle workflows
Preparation hypothesis: direct customer feedback and changing priorities on a small team may compete with maintainable architecture. Prepare an example of how you would scope an iteration, validate it with recruiters, and preserve clear service boundaries.

Practice your answers

Technical practice

How would you design services and APIs for jobs, candidates, assignments, and agent runs?

What to coverSuggested preparation: Explain the boundaries between these entities, how their states change, and what an API consumer needs to read or update. Discuss how you would keep the design maintainable as recruiter workflows evolve.

How would you authenticate an integration with a customer's ATS?

What to coverSuggested preparation: Walk through credential handling, access boundaries, and what happens when authentication expires or fails. Explain how you would diagnose an access problem without exposing sensitive data.

How would you keep ATS data synchronized using webhooks or polling?

What to coverSuggested preparation: Compare timeliness, implementation complexity, and failure modes for each approach. Describe how you would handle duplicate events, missed changes, and conflicting updates.

How would you make an ATS integration resilient to errors?

What to coverSuggested preparation: Distinguish transient failures from data or configuration problems, then explain retries, recovery, and when an issue needs attention. Address how you would avoid losing work or repeatedly processing the same change.

How would you design recruiter-facing views for sourcing boards, shortlists, screening results, and submissions?

What to coverSuggested preparation: Explain how you would learn which information recruiters need at each step and keep the views consistent with underlying data. Discuss a trade-off between showing useful detail and making the workflow fast to use.

How would you use an LLM to generate role-specific screening questions?

What to coverSuggested preparation: Describe what job information and constraints you would provide, and how you would check that questions are relevant and grounded in that information. Explain what you would do when the source information is incomplete.

How would you implement a structured screen using LLMs and tools?

What to coverSuggested preparation: Explain how you would preserve a consistent question-and-answer record while allowing appropriate follow-ups. Discuss how to handle ambiguous responses and prevent an agent from presenting unsupported conclusions as facts.

How would you generate a candidate profile or submission draft from screening information?

What to coverSuggested preparation: Describe how the draft would trace claims to available source information and flag gaps or uncertainty. Explain what a recruiter should be able to review or correct before using it.

How would you make agent behavior observable and debuggable?

What to coverSuggested preparation: Identify useful logs, monitoring signals, and alerts across an agent run and its external integrations. Explain how you would trace a failed or unexpected result while limiting unnecessary exposure of candidate information.

How would you evaluate whether an agent workflow is ready for production?

What to coverSuggested preparation: Propose checks for reliability, output quality, and maintainability, alongside a way to assess whether the workflow helps recruiters work faster or make better matches. Explain the trade-off between shipping an initial version and addressing failures found through use.

Behavioural practice

Tell me about a time you took a software project from idea to production.

What to coverSuggested preparation: Use a real situation to explain the scope you owned, the decisions you made, and how you got working software into use. Describe the result and what you learned about reliability or maintainability.

Tell me about a time you translated a non-engineer's workflow into a technical design.

What to coverSuggested preparation: Describe the stakeholder's goal, how you clarified the workflow, and the design choices you communicated. Explain what you built or changed and the resulting effect on that person's work.

Tell me about a time customer feedback changed a product you were building.

What to coverSuggested preparation: Give a real example of what you heard, how you distinguished the underlying need from a proposed solution, and what you changed. State the result and how you assessed whether the change helped.

Tell me about a time you worked through a technical trade-off with collaborators.

What to coverSuggested preparation: Describe the situation, the alternatives considered, and how you communicated a recommendation to people with different perspectives. Explain the decision, your contribution, and the outcome.

Tell me about a time priorities changed while you owned an important deliverable.

What to coverSuggested preparation: Explain what changed, how you reassessed impact and risks, and what you communicated to others. Describe the actions you took and the result without presenting a hypothetical achievement.

Sharpen your knowledge

Topics to prepare

Agent-platform architecture
Review how jobs, candidates, assignments, and agent runs relate; sketch service boundaries and data flow. The posting explicitly calls for owning core architecture, services, and APIs.
ATS integration reliability
Compare webhook and polling flows, then diagram how authentication, synchronization failures, and recovery affect data freshness. The role explicitly owns resilient ATS integrations.
Structured recruiting workflows with LLMs
Map the steps from a job description to role-specific questions, a structured screen, and a draft candidate profile. The posting names each of these agent-supported workflows.
Agent observability
Outline which events would help explain an agent run and which failures warrant an alert. Logging, monitoring, alerting, and debuggability are explicit responsibilities.
Recruiter workflow design
Trace how a recruiter might move from a sourcing board through a shortlist and screening results to a submission. These views are explicitly named, and the role uses customer feedback to improve them.

Skills to revise

Implement a small domain API
As practice, build endpoints for jobs, candidates, assignments, and agent runs, with clear error responses. This rehearses the core services and production-oriented backend work in the posting.
Build a resilient integration flow
As practice, connect two mock systems using authentication and either webhooks or polling; test failed requests and interrupted synchronization. This mirrors the specified ATS integration work without assuming a particular vendor.
Create a recruiter-facing view
As practice, build a simple shortlist or screening-results view backed by your API. The role includes implementing recruiter-facing UI, not just backend services.
Prototype a structured LLM workflow
As practice, generate role-specific screening questions and a draft profile from sample inputs, then inspect outputs for unsupported claims. The posting calls for hands-on LLM and tool use in these workflows.
Instrument and explain a run
As practice, add logs and a failure alert to the prototype, then use the recorded events to diagnose a failed agent run. The role emphasizes reliable, debuggable production behavior.
Translate feedback into a technical change
As practice, turn a hypothetical recruiter complaint about a shortlist into a brief design note and a scoped change. This prepares for the stated collaboration with the founder, AI Strategist, and early customers.

Your preparation checklist

Prepare a production project walkthrough
Choose a web or backend project you took from idea to production. Bring a diagram and a concise account of your decisions, reliability tradeoffs, and measurable impact; the role emphasizes shipping maintainable systems.
Sketch the agent platform architecture
As interview practice, diagram services and APIs for jobs, candidates, assignments, and agent runs. Explain data flow, ownership boundaries, and one tradeoff you would discuss with the founder and AI Strategist.
Work through an ATS integration design
Prepare a sample integration plan covering authentication, data synchronization, webhooks versus polling, retries, and error recovery. Mark assumptions to validate rather than presenting them as facts about Centh’s systems.
Demonstrate an LLM workflow
Walk through an LLM or agent project, or sketch a structured screening flow that generates role-specific questions and drafts a candidate profile. Show how you would review outputs and handle failures.
Connect recruiter views to dependable operations
Sketch a sourcing board, shortlist, or screening-results view and the data it needs. Add a brief plan for logging, monitoring, and alerting so agent runs can be investigated when something goes wrong.
Prepare a customer-feedback example
Bring an example of translating feedback from non-engineers into a technical change. Explain how you clarified the workflow, prioritized the change, and communicated the result; this role includes recruiter conversations and customer demos.
Write targeted questions for the team
Ask which ATS integrations and recruiter workflows are most important now, how agent behavior is evaluated in production, and how feedback from early customers shapes priorities.

Availability last checked: Nov 3, 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in United States. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…