AI Agent Engineer

What we’re looking for

An engineer who gets stuck in. You’ll embed with our clients, build AI agents that do real work inside a real business and get them into production.

This is one of the most important hires we’ll make this year. Every embedded partnership we sign has agents in the scope and client ambition is running well ahead of our capacity to build. We need someone who closes that gap by shipping, not by writing the strategy for someone else to ship.

You’ve done this before, more than once, on more than one stack. You know why an agent that demoed beautifully falls over in week three and you know it’s rarely the model’s fault.

We already have people in the team who are strong on n8n and Zapier. You’ll complement them, not duplicate them. When a workflow hits the limits of those tools, you’re the one who takes it further. When it needs a proper agent instead, you build that.

We’d rather be straight with you about the pace. We’re a small team running multiple live client projects, so you’ll have several builds on the go at once, real deadlines and a fair amount of time with clients and the team. If you want one project at a time and a fully async week, this isn’t the role. If you like a full plate and the judgement to sequence it, it probably is.

What you’ll be responsible for

• Build and ship AI agents into live client environments, on whichever harness or runtime fits, from Microsoft Foundry to Claude to open-source harnesses like OpenClaw and Hermes Agent. Live users and live data, which means it matters when something breaks.

• Work a real backlog across several clients at once. On a typical week that might be a list of ten-plus agents and automations for one partnership, rework on agents already running for another and a scoping session for a third. You’ll sequence it, say what’s realistic and tell us early when something has to give.

• Take over where n8n and Zapier run out of road. Custom code, self-hosting, error handling at volume and knowing when a workflow should move off a no-code tool and onto a proper agent runtime.

• Take over agents you didn’t build. Reverse-engineer what a client set up on a no-code platform, work out why it’s slow, expensive or unreliable, and rebuild it on something better where that’s the right call.

• Build on the Microsoft stack when that’s where the client lives. Several of our clients run on Azure and Microsoft 365, so you’ll build in Microsoft Foundry, register and govern agents through Microsoft Agent 365 and get them in front of people inside Teams and Microsoft 365 Copilot.

• Run discovery. Sit with a client’s operations, sales, support or finance teams and work out which processes are worth automating and which agents are worth building. Plenty aren’t. Saying so early is part of the job.

• Work out the infrastructure and access an agent needs before you write anything: credentials, permissions, connectors into the client’s systems, data access, rate limits, service accounts, audit trails and where a human has to stay in the loop.

• Build everything around the agent that makes it dependable. Triggers, queues, error handling, retries, fallbacks and monitoring. An agent that fails quietly at 2am is worse than no agent at all.

• Pick the right harness for the job rather than the one you’re most comfortable with, and explain that choice to an engineer and to a CFO in the same week.

• Be the technical lead for how we build. Own our agent and automation delivery process end to end, from scoping and decision-making through to testing against live work and the feedback loop after launch, so the rest of the team and the hires after you can pick up a build and help rather than wait for you.

• Hand it over twice. Documentation and a working session for the client team so they can run it without us in the room, and the same again internally so nobody here is guessing how it works while you’re on holiday.

• Turn one-off client builds into reusable patterns in the Agents and Workflows areas of our platform, working with the business owner for those areas, so the second time is faster than the first.

• Keep us honest on new tooling. When a new agent builder lands from OpenAI, Anthropic or Microsoft, get hands-on with it and tell us whether it changes what we build for clients.

• Automate Inovara itself. We use AI heavily internally and there’s still plenty we do by hand that we shouldn’t.

A bit more about you

• You’re hands-on first. You’d rather show a working build on Friday than present a plan on Monday, and your best work is running in production somewhere right now.

• You’ve built and shipped real agents across several harnesses and runtimes, in production, not in a sandbox. We’re looking for direct experience with most of these, or equivalent experience on parallel platforms:

  • Microsoft: Microsoft Foundry and Foundry Agent Service, Microsoft Agent Framework (the successor to AutoGen and Semantic Kernel) and Microsoft Agent 365

  • Claude: Claude Code, the Claude Agent SDK, Skills and MCP servers

  • Open-source operational agents: OpenClaw and Hermes Agent

  • Code-first runtimes: LangGraph, the OpenAI Agents SDK, and Letta or similar for persistent memory

  • Coding harnesses you use every day: Codex, Cursor, GitHub Copilot or Cline

• We care that you’ve made a considered choice between harnesses, not that you know one vendor deeply. Tell us which you’d pick for what, and why.

• Deep n8n and Zapier (or Make) experience, well beyond building flows. Code nodes, self-hosting, sub-workflows and error handling at volume, so you can take the team further when they hit a wall.

• You’ve built on the Microsoft stack in a real environment. Azure, Microsoft Foundry (including Foundry Agent Service) and Microsoft Agent 365, plus publishing agents into Teams and Microsoft 365 Copilot with Entra ID permissions set up properly. This one isn’t optional.

• You’re comfortable with the unglamorous half of the work. Auth flows, scopes, secrets management, webhooks, logging, cost control and the API with the undocumented limit nobody warned you about.

• Solid engineering foundations. Python or TypeScript, confident with APIs and enough infrastructure knowledge to deploy and maintain what you build.

• You can hold a discovery conversation with someone non-technical and come out with a buildable spec. That means excellent spoken English and the judgement to leave the technical detail at the door when it isn’t helping the person in front of you.

• You can juggle several builds without dropping one, and you’re upfront when the plate’s full rather than quietly missing a deadline.

• You can show us your work. Two or three agents you’ve built, running live, with at least one on a code-first harness or runtime rather than a no-code tool, plus what happened to the business afterwards. Hours saved, error rate, cycle time, revenue touched, whatever the honest number is.

• Pragmatic. A simple thing that runs every day beats a clever thing that needs babysitting.

• Direct Selling experience is a plus, not a requirement. Learning a client’s world quickly matters more, and we’ll train you on the industry.

Nice to have

• Copilot Studio, Power Automate or the wider Power Platform

• Evals, observability or agent monitoring used in anger

• Retrieval-Augmented Generation and vector databases

• Enough frontend to put a usable interface on something

• Multi-agent orchestration, including a view on where it stops being worth the complexity

• Voice agents in production

• Security, data protection or compliance experience in a regulated environment

• Agency or consultancy background, working across several client environments at once

How this process works

We’re not hiring off a CV and a good conversation. Agent work is one of the easiest things in the world to talk convincingly about without having actually done it, so every stage after the first asks you to show rather than tell.

1. Intro call, 30 minutes

2. Live demo with our core team. Screen share, no slides. Run two or three agents you’ve built, at least one on a code-first harness or runtime, show us the guts of at least one and tell us what it was worth to the business.

3. The build. We’ll hand you a real problem, close to one we’ve hit with an actual client, and you’ll build something that works and walk us through it. Expect at least part of it to involve the Microsoft stack. We want to see the calls you made, the ones you rejected and the parts you’d rebuild given more time.

4. Handover to our core team, run the way you’d hand over to a client

5. Final conversation with Dan and Matt (founders)

We know that’s a fair amount of work and we don’t take it lightly. It’s also the best way for us both to find out whether this is the right fit.

What we’re offering

Ownership of the agent build inside a fast-growing AI consultancy, with client exposure from day one and real freedom over how we build.

A permanent, fully remote role with the potential to participate in our share option scheme.

Influence over our platform and our tooling. Build something good here and it goes into every partnership we run.

Interested? Get in touch

If this sounds like it was made for you, get in touch and tell us why.

If it doesn’t, but you still like the sound of Inovara, drop us a line anyway. We’re hiring in all sorts of positions across the business.