Artificial Intelligence Engineer

Talent Forge Group; Sydney; On-site; AUD 180,000 - 220,000; Full time

Job summary

Talent Forge Group in Sydney, Australia is seeking a senior engineer to own the model engineering for an agent-driven travel platform. You’ll shape the architecture and work directly with the founder to deliver reliable, live bookings across supplier APIs and policy rules.

You’ll design the agent runtime, memory and tooling, ensure safe, scalable execution, and build observability around latency and cost per task. The role demands deep backend experience and hands-on leadership from day one.

Qualifications

• Experience shipping stateful LLM agents with external integrations.
• Proven ability to explain architecture and execution of agent runtimes.
• Strong backend depth: Postgres, transactions, caching, and distributed failure modes.

Responsibilities

• Design agent runtime and harness orchestration, including checkpointing and budgets.
• Develop context engineering and persistent memory management.
• Implement typed tools and MCP integrations with safety against prompt injection.
• Ensure reliable transactions with idempotency and reconciliations.
• Collaborate with founder and own architecture.

Skills

Python asyncio

Stateful LLM agents

Agent framework explanations

PostgreSQL

Distributed systems

Security fundamentals

Job description

• $180k-$220k + super + bonus

Most “AI engineer” roles mean wiring an LLM into a chatbot. This one is about the hard part: making agents that take real, consequential actions and get them right every time.

Our client is building an agent-driven travel platform. Its agents turn natural-language requests into live bookings and servicing work across supplier APIs, reservation terminals, company travel policies and persistent booking records. When a supplier times out halfway through a booking, the system has to know what actually happened before it tries again.

They’re looking for a senior engineer to own the engineering around the model, working directly with the founder and owning much of the architecture.

What you’ll work on

• Agent runtime and harness design: orchestration, checkpointing, cancellation, budgets, concurrency and handling provider failures
• Context engineering and persistent memory, including history compaction, prompt-cache efficiency and memory scoped correctly to each user and company
• Typed tools and MCP integrations, keeping model intent separate from deterministic validation and execution, with protection against prompt injection
• Reliable transactions: idempotency, reconciliation, authoritative readback and approvals tied to the exact action being approved
• Subagent delegation and longer-running workflows
• Evaluation and observability: replay suites, correlated traces, and tracking task success, latency and cost per task

The stack

What you’ll bring

• Strong production Python, including asyncio, typed interfaces and debugging concurrent systems
• You’ve shipped stateful, tool-using LLM agents to real users with external integrations
• You can explain how your agent framework or custom runtime actually executes, not just how to call it
• Solid backend depth: Postgres, transactions, migrations, caching and distributed-system failure modes
• You’ve built evals for probabilistic systems and used traces to diagnose failures
• Security fundamentals: tenant isolation, least-privilege tool access and handling sensitive data

Bonus:

• contributions to agent SDKs, MCP servers or eval frameworks
• GDS/NDC or booking/payment workflows
• terminal-based or multi-channel (web, messaging, voice) agents
• model routing and inference optimisation

Why it’s worth a conversation

You’ll have real ownership from day one. In your first 90 days you’ll map the runtime, set a quality, latency and cost baseline, and ship a harness improvement you can measure.

If you’ve built an agent that did meaningful work through tools, and you can talk through how you diagnosed a failure and proved the fix worked, we'd love to hear from you.