> Markdown version of [/jobs/ext/3569288-ai-solution-engineer-security](https://www.wearedevelopers.com/jobs/ext/3569288-ai-solution-engineer-security). Every page supports `.md` or `Accept: text/markdown`. Links point to the HTML versions so they work for humans too. Agent guide: [/agents.md](https://www.wearedevelopers.com/agents.md). --- # AI Solution Engineer, Security - **Company:** Dell Technologies Inc. - **Location:** Round Rock, TX, United States - **Experience:** Expert - **Contract:** Internship / Graduate position - **Skills:** JavaScript (Programming Language), Application Programming Interfaces (APIs), Artificial Intelligence, Computing Platforms, Systems Engineering, Audit Trail, Computer Programming, Data Sharing, Cursor, Distributed Systems, Python (Programming Language), Open Web Application Security, Systems Development Life Cycle, Software Engineering, TypeScript, Management of Software Versions, Software Vulnerability Management, Enterprise Data Management, GitHub Copilot, Large Language Models, Claude Code, Prompt Engineering, Software Security, AI Coding Agents, Event Driven Architecture, Information Technology, Data Management, Machine Learning Operations, Drift Detection, Invoking Functions, Model Context Protocol, Devsecops - **Published:** October 3, 2026 - **Apply:** https://www.jobmonkeyjobs.com/career/28077644/Ai-Solution-Engineer-Security-Texas-Round-Rock-1312 ## About the Role * 12+ years in software engineering, security engineering, or platform architecture, with a record of production delivery rather than advisory or research-only work * AI and agentic systems delivered into production and kept there, with measurable operational or business impact * Deep hands-on capability in agentic system engineering, including: Agent loop design: planner and executor patterns, sub-agent delegation, tool and function calling, state management, checkpointing and resumability across long-running workflows, and idempotency for agents that take consequential action - Context engineering: agentic retrieval and search, memory architecture, grounding in enterprise data, context compaction, tool and schema design, and structured or schema-constrained output - Determinism boundary design: placing model reasoning where judgment is genuinely required and deterministic logic where a verdict, gate, or calculation must be reproducible- Evaluation engineering: golden sets, offline and online evaluation, regression suites, acceptance thresholds, and the limits of model-graded evaluation - Production economics: token budgeting, prompt and response caching, model selection and routing with fallback, and latency and cost targets held as design constraints * Design of agent authorization and identity: non-human identity, scoped and least-privilege credentials, delegation, action approval, and audit trails that hold up under review * Ability to threat model an agentic system and design against prompt injection, tool abuse, untrusted content in the context window, and exfiltration through agent surfaces * Strong programming proficiency (Python, TypeScript/JavaScript, Go, or similar). This role designs, prototypes, and reviews code; it does not stop at diagrams * Distributed systems and integration engineering: API and event-driven design, schema and contract versioning, retry and backpressure behavior, and observability including trace-level visibility into agent execution * Data modeling across systems of record, including entity resolution and reconciliation of overlapping representations of the same asset, finding, or owner * Demonstrated experience leading cross-functional process consolidation, bringing together teams that hold separate processes, conflicting requirements, and existing tooling investments, and landing a single agreed design those teams adopt * Working knowledge of security engineering sufficient to design credible security workflows in application security, vulnerability management, threat modeling, secure SDLC, or an equivalent domain * Demonstrated influence without authority at senior levels, communicating equally well to engineers building from a design and executives deciding on it * Bachelor's or master's degree in computer science or a related field, or equivalent practical experience Desired Requirements * Experience applying agentic AI within a security domain such as application security, DevSecOps, vulnerability management, threat modeling, or software supply-chain security * Experience building MCP servers, agent skills and tools, or extending AI coding assistants such as Claude Code, GitHub Copilot, or Cursor * Familiarity with secure-by-design and secure-by-default principles and relevant frameworks, including the OWASP Top 10 for LLM Applications, NIST SSDF, and NIST AI RMF * Experience with LLMOps in production, covering versioning, staged rollout, regression detection, and behavioral drift monitoring, and with automated processes that remain defensible under audit * Prior senior individual contributor role (Principal or above) carrying organization-wide design authority ## Description We are seeking a Senior Principal Engineer to serve as the design authority for how security work is reconstituted as AI-native capability. This is a senior individual contributor role with no direct reports and substantial technical authority: the solution designs, agent authority boundaries, and reference patterns produced by this engineer determine what gets built and to what standard. Security work today is spread across many functions, each with its own intake path, tooling, and definition of done. The result is duplicated effort and process that runs at human speed while the systems it protects run at machine speed. This role works alongside functional owners and practitioners across security to collapse many processes into one, and to embed the resulting capabilities into the business and engineering processes they serve, so that security is intrinsic to how work is done rather than a gate applied to it. You will: * Own the solution design for AI-native security workflows from problem statement through buildable specification: agent topology and decomposition, the boundary between model reasoning and deterministic logic, tool and data surfaces, state and context strategy, human decision points, and defined failure behavior * Determine what should be agentified, assessing whether the work is better served by an agent, by deterministic automation, or by leaving it unchanged, and document reasoning that withstands challenge * Collaborate with functional owners and practitioners across security to establish how work is actually performed, identify where separate functions perform the same work under different names, and design the single consolidated process that replaces them, including the shared data and evidence model that makes one process possible, resolving conflicting requirements rather than accommodating all of them * Define authority boundaries for every agent: what it is permitted to do, what requires human confirmation, what it must never do, and how those limits are enforced through scoped credentials and technical controls rather than by convention * Design against attacks on the agentic system itself: prompt injection, tool abuse, untrusted content reaching the context window, and data exfiltration through agent surfaces * Baseline current cycle time, manual touch points, and rework before designing the replacement, so improvement is measured rather than asserted, and define what is retired once the unified workflow lands * Design for verifiability and failure containment: the evidence and traces each workflow emits, deterministic criteria for what a passing outcome means, the blast radius of an incorrect agent action, and the rollback and escalation paths * Design how agentic workflows integrate with the systems security work runs on, including security tooling, systems of record, identity and access, data platforms, and the collaboration surfaces where work is requested and reviewed, using APIs, event streams, and protocols such as MCP (Model Context Protocol) * Establish the reusable foundation of reference architectures, agent primitives, orchestration and context patterns, evaluation harnesses, and integration templates, holding token cost, latency, and reliability as design constraints rather than post-launch concerns