New opportunity

Senior Applied AI Engineer

MathWorks · Natick, United States

About this role

MathWorks is seeking a Senior Applied AI Engineer for its Applied AI team in Natick, Massachusetts. The role builds an agentic AI platform and AI-powered developer tools to support how the company plans, builds, delivers, and monitors software. The position follows a hybrid model, splitting time between the office and home.

Responsibilities

  • Architect core platform capabilities, including agent orchestration, an SDK, sandboxed runtime environments, and LLM gateway infrastructure.
  • Evaluate and integrate external frameworks and open-source tools for agent orchestration and context management, considering security, extensibility, and developer experience.
  • Make architectural, code-quality, and build-versus-buy decisions; establish patterns for safe AI-agent use in software development workflows and drive their adoption.
  • Break down ambiguous technical problems, mentor engineers through code review and design collaboration, and work with stakeholders to identify automation opportunities and shape the developer-tooling roadmap.
  • Keep pace with developments in AI tooling, agent architectures, and LLM capabilities and apply them to platform decisions.

Minimum qualifications: A bachelor’s degree and 6 years of professional work experience, a master’s degree and 3 years of professional work experience, a PhD, or equivalent experience; expertise in Python. Because the posting offers alternative qualification paths, it does not specify one overall minimum experience requirement.

Additional qualifications: Experience with deterministic and LLM-driven agent orchestration, sandboxed execution, tool integration, and context engineering; AI/ML evaluation, observability, or quality assurance in production; and developer platforms, SDKs, or tools adopted by other teams. The posting also seeks communication and cross-team technical leadership, sound build-versus-buy judgment, understanding of enterprise AI security and access control, and experience with CI/CD, code review systems, and testing infrastructure.

The stated salary range is USD 135,700–210,400 annually.

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

Skills for this role

PythonAI agentsAgent orchestrationLLM application developmentContext engineeringTool integrationSandboxed executionSDK developmentDeveloper platformsAI evaluationObservabilityQuality assuranceAI securityAccess controlCI/CDCode reviewTesting infrastructureTechnical architectureTechnical mentoringStakeholder collaboration

Your skill match

Checking your profile…

YOUR NEXT STEP

Get interview-ready for this role

A focused preparation guide, built around this job’s responsibilities and requirements.

✦ AI-generated guide
Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.
01

Understand the role

What matters most

  • Architect the agentic AI platform

    The role owns architecture for agent orchestration, an SDK, sandboxed runtimes, and LLM gateway infrastructure. Python expertise is a minimum qualification.

  • Make durable tooling decisions

    The posting calls for evaluating external frameworks and open-source tools against security, extensibility, and developer experience, while exercising build-versus-buy judgment and maintaining code quality.

  • Make agents safe and measurable

    The role defines patterns for safe agent use in software-development workflows. Additional qualifications emphasize sandboxing, access control, and evaluation or observability that can measure and improve production behavior.

  • Shape tooling that teams adopt

    The engineer partners with development stakeholders to find high-leverage automation opportunities, shape the roadmap, and drive adoption of platform patterns and developer tools.

  • Lead through ambiguity and collaboration

    Responsibilities include decomposing cross-cutting problems, mentoring through design and code review, and communicating technical direction across teams.

Likely challenges to think through

  • Balancing agent flexibility with control

    A likely design tension is allowing useful LLM-driven orchestration and tool integration without weakening sandboxing or access control. Prepare to explain how you would set execution boundaries and evaluate agent behavior; this is a preparation hypothesis, not a reported platform issue.

  • Choosing foundations in a fast-moving field

    Frameworks and LLM capabilities can change faster than a shared platform should. Prepare a decision approach that weighs build-versus-buy, security, extensibility, developer experience, and maintainability; the posting explicitly describes this domain as fast-moving.

  • Turning broad opportunities into adopted workflows

    Potential automation across planning, building, delivery, and monitoring must be narrowed into actionable work that other teams will use. Prepare to discuss how you would learn existing CI/CD, review, and testing workflows, prioritize opportunities with stakeholders, and assess adoption; no particular adoption obstacle is stated.

03

Practice your answers

Technical practice

Suggested practice: How would you architect an agentic AI platform for developer tooling?

What to coverThe role covers agent orchestration, an SDK, sandboxed runtimes, and LLM gateway infrastructure. Explain the boundaries between these components, how they interact, and where you would enforce security and maintainability.

Suggested practice: When should agent orchestration be deterministic rather than LLM-driven?

What to coverThe posting specifically mentions systems that combine both approaches. Discuss where predictable control flow matters, where LLM decisions add value, and how you would handle failures or unexpected agent behavior.

Suggested practice: How would you design safe execution for an agent that uses development tools?

What to coverSandboxing, access control, tool integration, and safe agent execution are stated concerns. Describe permission boundaries and how you would limit and inspect actions without making the tools unusable.

Suggested practice: How would you manage context for an agent working across software-development tasks?

What to coverThe posting names context engineering and context-management systems. Explain how you would select and update relevant context, manage its limits, and evaluate whether it helps the agent complete a task accurately.

Suggested practice: What responsibilities belong in an LLM gateway?

What to coverLLM gateway infrastructure is a named platform capability. As a design suggestion, discuss centralized access controls, observability, and model integration, including what should remain the responsibility of applications using the gateway.

Suggested practice: How would you design a Python SDK that other engineering teams can adopt?

What to coverThe role requires Python expertise and involves building an SDK and internal developer tooling. Discuss API clarity, extensibility, testing, and how you would learn whether the SDK works well for its users.

Suggested practice: How would you decide whether to integrate an external agent framework or build a capability internally?

What to coverThe posting calls for framework evaluation and build-versus-buy judgment. Compare security, extensibility, developer experience, maintainability, and the cost of integrating a framework into an enterprise platform.

Suggested practice: How would you evaluate and troubleshoot agent behavior in production?

What to coverThe posting seeks evaluation, observability, or quality-assurance experience, including measuring, tracing, and improving behavior. Explain what evidence you would collect, how you would investigate a failure, and how findings would inform a change.

Suggested practice: Where could AI agents fit into existing software-development workflows?

What to coverThe team supports how MathWorks plans, builds, delivers, and monitors software; CI/CD, code review, and testing infrastructure are also named. Choose a workflow and explain a bounded use case, its safeguards, and how you would assess whether it improves the workflow.

Behavioural practice

Suggested practice: Tell me about a time you turned an ambiguous technical problem into an actionable plan.

What to coverScoping cross-cutting, ambiguous work is a stated responsibility. Use a real situation, explain how you clarified constraints and divided the work, and describe the result.

Suggested practice: Tell me about a time you helped an engineer improve a design or code change.

What to coverThe role includes mentoring through code review and design collaboration. Describe the situation, the feedback or collaboration you provided, and the resulting change without overstating your individual contribution.

Suggested practice: Tell me about a time stakeholder input changed a technical roadmap or automation priority.

What to coverThe posting calls for understanding development workflows and identifying high-leverage automation opportunities. Explain whom you consulted, how you weighed the input, what you did, and what resulted.

Suggested practice: Tell me about a time you drove adoption of a technical practice across teams.

What to coverThe role involves setting patterns for AI-agent use and influencing engineering practices beyond one team. Give a real example of the situation, your approach to alignment and communication, and the outcome.

Suggested practice: Tell me about a time you explained a difficult architecture trade-off to different audiences.

What to coverThe posting emphasizes consequential technical decisions and communication with engineering and non-engineering audiences. Describe the decision, how you adapted your explanation, the actions others took, and the result.

02

Sharpen your knowledge

Topics to prepare

  • Agent orchestration and context engineering

    The posting calls for agent systems combining deterministic and LLM-driven orchestration, tool integration, and context engineering. Revision exercise: diagram a developer-workflow agent, marking which decisions are fixed, which use an LLM, and what context each step receives.

  • Agentic platform architecture

    The role architects orchestration, an SDK, sandboxed runtimes, and LLM gateway infrastructure. Revision exercise: sketch their interfaces and trace one request through the system, noting where failures and access decisions occur.

  • Enterprise AI security

    The posting names sandboxing, access control, and safe agent execution. Revision exercise: review a proposed agent that can inspect code and invoke tools; identify its trust boundaries, permitted actions, and failure containment.

  • Evaluation and production quality

    Additional qualifications include measuring, tracing, and improving AI/ML system behavior in production. Revision exercise: define success and failure measures for an AI-powered developer tool and outline how a trace would support diagnosis.

  • Framework selection and build-versus-buy

    The role evaluates external frameworks and open-source tools against security, extensibility, and developer experience. Revision exercise: draft a decision matrix and explain when building an internal component would be preferable to integrating one.

  • Developer-workflow adoption

    The team supports how MathWorks plans, builds, delivers, and monitors software; the posting also names CI/CD, code review, testing infrastructure, and cross-team adoption. Revision exercise: map one workflow, identify an automation opportunity, and explain how to assess its value with stakeholders.

Skills to revise

  • Python implementation and review

    Python expertise is a minimum qualification, and the role makes code-quality decisions. Practice exercise: implement a small, testable Python orchestration flow, then review it for maintainability, error handling, and security.

  • SDK and gateway interface design

    The role builds an SDK and LLM gateway infrastructure. Practice exercise: write a minimal SDK interface that sends requests through a gateway abstraction; test how it reports invalid inputs and gateway failures. This is a preparation exercise, not a specified implementation.

  • Sandboxed tool execution

    Sandboxed runtimes, tool integration, and safe agent execution are explicit in the posting. Practice exercise: prototype a tool-invocation boundary with an allowlist and access checks, and test a denied action.

  • Behavior tracing and evaluation

    The posting seeks experience with evaluation, observability, or quality assurance systems. Practice exercise: instrument a sample agent run with step-level traces, assemble representative success and failure cases, and use the results to propose one improvement.

  • Technical decision communication

    The role requires architectural judgment, mentoring through design and code review, and communication across teams. Practice exercise: write a short design review comparing two orchestration approaches, state a recommendation and tradeoffs, then explain it separately for engineers and non-engineering stakeholders.

04

Your preparation checklist

  • Select a Python platform walkthrough

    The posting requires Python expertise and seeks developer tooling adopted by other teams. Prepare one relevant project walkthrough, if available, covering the architecture, your decisions, code quality, and evidence of adoption.

  • Sketch an agentic platform design

    Practice a design exercise connecting deterministic and LLM-driven orchestration, an SDK, sandboxed runtimes, tool integration, context management, and an LLM gateway. Produce a diagram and explain access controls and safe execution.

  • Build a framework decision matrix

    The role evaluates external frameworks and open-source tools. Prepare a sample build-versus-buy comparison using security, extensibility, developer experience, maintainability, and integration effort; state what evidence would change your choice.

  • Prepare an AI quality case study

    The posting seeks evaluation, observability, or quality-assurance experience. If you have a relevant example, show what you measured and traced in production, how you investigated failures, and what improved; otherwise, outline how you would evaluate a proposed agent workflow.

  • Gather technical-leadership examples

    Prepare concise examples, where available, of decomposing ambiguous work, improving a design through code review, mentoring engineers, and explaining a technical decision to both engineering and non-engineering audiences.

  • Map a developer-workflow opportunity

    As a preparation exercise, choose a plausible CI/CD, code-review, or testing workflow. Draft questions you would ask stakeholders, a bounded automation proposal, its safety checks, and how you would assess whether other teams adopt it.

  • Write questions for the MathWorks team

    Ask which platform capabilities are already in place, how security and developer experience shape framework choices, which software-development workflows are priorities, and how the team evaluates agent behavior and adoption.

AI-generated from the job information · Prepared Sep 30, 2026 (UTC)Useful preparation, not a guarantee of eligibility or an offer.

Availability last checked: Nov 4, 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…