Agent Fleet Architect

Position Overview

The Agent Fleet Architect will build the operating system for an AI-native organization.

We are looking for someone who sees AI differently: not as a collection of copilots, not as isolated automations, and not as a graveyard of bots. You see systems. Agents talking to agents. Tools exposing capabilities. Context flowing across the organization. Humans stepping in where they add value. Work moving automatically from trigger to outcome. You want to build the layer that makes all of this work together.

The mission

We become an AI-native organization, not a company that happens to use AI. A company designed around humans, agents and software systems working together. Our engineering teams build the foundations: APIs, data, permissions, MCPs, CLIs, knowledge, tools and reliable internal capabilities. They make the organization understandable and accessible to machines.You make it actionable. You take those capabilities and turn them into agents, fleets and workflows that actually get work done. Engineering builds the rails. You make the trains move.

You build fleets, not bots

One agent is interesting, but a hundred disconnected agents are chaos. The real opportunity is in designing how they work together.

You think about:

• Who does what, and in what order?
• What does each agent need to know?
• Which model, agent, human or tool should handle the next step?
• How does work move without losing context?
• How do we build something once and make it available everywhere?
• What should persist, where, and for whom?
• What is each agent allowed to know and do?
• How do we know what happened when something goes wrong?
• Human-in-the-loop. Where do people add judgment instead of friction?

You are designing the connective tissue of the organization.

You care about the workflow

You are not impressed because an agent can perform one clever task.

You want the whole loop:

• A signal appears.
• An agent understands it.
• It gathers the right context.
• It calls the right tools.
• It delegates part of the job.
• Another agent picks it up.
• A human approves something important.
• A system gets updated.
• Slack gets notified.
• The next action happens automatically.
• The loop closes.

That is what you care about. Not the demo. The workflow.

Deep engineering underneath. Ridiculous speed on top.

You believe great engineering and low-code belong together. Deep engineering teams should not spend their lives building every individual automation, they should build powerful primitives: APIs. MCP servers & CLIs. Identity. Permissions. Structured data. Reusable tools. Reliable infrastructure. Then builders should be able to combine those primitives into powerful agents and workflows at extraordinary speed.

You understand why a low-code agent sitting on top of excellent engineering infrastructure can be more valuable than another bespoke application living in isolation. You want engineering to make more of the organization programmable. Then you want to unleash it.

You understand the technology

• You are not a no-code tourist.
• You have written code.
• You understand software systems.
• You can read an API spec.
• You know what an OAuth flow is doing.
• You can inspect a payload.
• You understand webhooks, schemas, databases and data structures.
• You can trace why an integration broke.
• You can write some code when code is the right answer.
• And, importantly, you know when it isn't.
• Your superpower is knowing when to:
  • code it
  • configure it
  • connect it
  • delegate it
  • or not build it at all

You are technical enough to work deeply with engineering without needing to turn every idea into an engineering project.

Your natural habitat

• MCP.
• A2A.
• Tool calling.
• Agent routing.
• Agent memory.
• Multi-agent orchestration.
• OpenClaw.
• Grok bots.
• LS Fleet.
• CrewAI.
• Slack automations.
• APIs.
• Webooks.
• Low-code platforms.

Hands-on experience with the Ximosing framework

Whatever appeared three weeks ago that might make all of this 10x better. The exact stack will change. That does not bother you. You are interested in the architecture underneath it.

You think in systems

You open a company and see a graph.

•    People.
•    Knowledge.
•    Tools.
•    Agents.
•    Permissions.
•    Data.
•    Systems.
•    Actions.
•    Workflows.

And connections that should exist but don't.

You instinctively believe in:

• systems over silos
• workflows over features
• capabilities over applications
• fleets over bots
• outcomes over demos

You see two systems that cannot talk to each other and it physically annoys you.

You probably can't help yourself

• You don't need someone to tell you AI agents are going to matter.
• You are already building with them.
• You see a new model and immediately wonder what you can connect it to.
• You sit through a manual process and redesign it in your head before the meeting ends.
• You have prototypes nobody asked for.
• You have diagrams that explain how six systems should really be one system.
• You see 1,000 opportunities and your main problem is deciding which one to build first.
• You have the curiosity of a hacker.
• The judgment of someone who understands engineering.
• The impatience of someone who can already see what is possible.

In some ways, you are an agent that escaped its own orchestration layer.

What you'll actually do

You will:

• architect and operate fleets of AI agents;
• connect agents, tools, people and systems into end-to-end workflows;
• build with APIs, MCP, A2A, webhooks and emerging agent protocols;
• create low-code and no-code agents on top of robust internal capabilities;
• design agent routing, delegation and handoffs;
• build deeply into Slack and the places where work actually happens;
• turn engineering capabilities into reusable agent tools;
• create shared patterns rather than isolated automations;
• prototype aggressively and ship quickly;
• work with engineering on what should become reusable infrastructure;
• decide when an agent should act, delegate, ask or escalate;
• make the fleet observable, understandable and increasingly autonomous;
• constantly test new models, tools and architectures;
• and kill things that looked clever but do not actually make the company better.

What this role is not

• This is not an AI strategy role. You build.
• This is not traditional enterprise architecture. You ship.
• This is not a queue of automation tickets. You think beyond the individual request.
• And this is not a pure software engineering role.
• You should absolutely understand engineering, but your job is to compose capabilities into working systems, not reinvent every capability from scratch.

You sit in the space between engineering infrastructure × agent architecture × automation× product thinking × operations. That space is where things get interesting.

Where we're going

Imagine an organization where:

• a new capability built by engineering can immediately become available to dozens of agents.
• agents can discover and use the right tools.
• context moves with the work.
• systems collaborate instead of living in silos.
• humans are brought in for judgment, creativity and relationships — not copy-pasting information between applications.
• new workflows can go from idea to production in hours or days.
• increasingly complex work can be completed by fleets of specialised agents operating together.

That is what we want to build. Your job is to architect the fleet that makes it possible.

Salary range: €50,000 - €70,000 per year