Agentic Systems Engineer

About Rangle#

Rangle is a Toronto-based consultancy building quality software for enterprise clients since 2013. We're a cross-functional team of designers, product managers, and engineers working shoulder-to-shoulder on production systems for clients ranging from startups to some of the largest enterprises in pharma, finance, and retail.

We run agentic development as a first-class practice. Not "we use AI tools," not "we're experimenting with Claude." We're reshaping how teams compose, how delivery works, and how software gets shipped around the reality that AI has changed the math. We build orchestration that runs agents across a whole project, custom tooling that encodes our team's judgment, and custom products when our team needs them. Restraint, curiosity, and ambition in equal parts.

Sovereignty as capability. We help clients own what their AI runs on: the infrastructure, the data, the agents and workflows that do the work, and the freedom to switch models. We run on that same kind of stack ourselves. Our own platform is built on Kubernetes from open-source components, and it hosts our internal tools and the products we sell. For a Canadian or European client, that ownership answers the question of where their data lives and whose laws reach it.

About this Role#

This is a hands-on technical leadership role. You'll work on live client projects, lead the engineering side of a cross-functional team, and ship production code alongside review, pairing, and architectural work. Most of what we build is customer-facing: products real people and businesses use directly, where the interface, the API, and the data behind it all have to hold up under real use.

You also build the meta-systems that let the rest of the team ship confidently: CLAUDE.md files, agent rules, Claude Code skills, MCP servers, evals, test harnesses, and reusable patterns. If an agent can produce bad code on your project, the harness you wrote catches it before it ships.

You work alongside an Agentic Managing Director (AMD) who owns the client relationship and Agentic Product Engineers (APEs) who move fast within your scaffolding. Your job is to make both of them faster, and to represent the engineering lane when the team is making trade-offs with design, product, and the client together.

Engagements often reach into platform work (Kubernetes, declarative infrastructure, GitOps). You don't need that background to join; we teach it when an engagement calls for it.

What a Week Looks Like#

You work directly with the client as one team, often starting from little more than a framing of the goals, and you turn that into solutions built on sound architecture and good coding practice. Claude does much of the typing, and you're the one who notices where its output is subtly wrong, where the harness needs adjusting, and what the team should learn from it. You know how the features of the application fit together, so when a client asks on a call how something works, you can answer, and you raise it quickly when our approach is off.

What You'll Do#

• Define the solution before the build. Turn a written problem into a sound solution the team can build from. Name the risks and rabbit holes early and decide what stays out
• Ship production code on real client projects alongside the team. This is not a purely advisory seat
• Architect the systems your team is building: component patterns, data models, API shape, testing strategy, delivery pipeline. Review PRs for system coherence, not just correctness
• Build and harden the agentic tooling your team depends on: rules, skills, MCP servers, Claude Code plugins, mods, and hooks, evals, and the harnesses that verify agent output and keep AI-generated work within guardrails. That includes durable agent workers that run on our own infrastructure, picking up work in the background and reporting back for review. Contribute patterns back to our shared template and knowledge repo so the next project starts further ahead
• Make the blueprint-vs-codebase call. Know when to build disposable (to iterate) and when to build integrated (to scale)
• Pair with APEs while architecture is still forming, coach them on architectural thinking, and hand off cleanly once the pattern is established
• Partner with designers, product managers, and clients on trade-offs. Push back when the ask doesn't match the goal, including advocating for client ownership over vendor lock-in when that serves them better

How We Work#

• Cross-functional from day one. Every delivery team ships with designers, product managers, engineers, and agile practitioners working together. You'll be in the room where trade-offs get made.
• Lean agile, low process. One- or two-week sprints, regular demos, continuous client feedback. We value working software and direct conversations over documents and ceremonies.
• Project rotation and variety. Nobody stays on a single engagement forever. Roughly six to eight months on average, with a two-year ceiling. You'll work across industries, codebases, and client contexts rather than calcifying on one stack.
• Remote-first, hybrid. The team is based in the Toronto area and works remotely most of the time, meeting in person when it helps. Expect more in-person time as the team grows.
• Client-facing, not client-owned. You'll talk to clients regularly alongside a project lead, but you won't carry the commercial weight of the engagement on your own.

Qualities That Will Help You Thrive#

• Taste. You know good from great. UI, architecture, prose, API design; you hold a standard
• Low ego, high standards. You multiply the team. You'd rather ship a teammate's PR than your own if it moves the project further
• Client-ready. You can sit in a room with a VP and explain a trade-off without dumbing it down or geeking out (unless that's what the audience needs to hear)

Qualifications#

Required#

• 5+ years of production software across several products or teams, with architectural ownership on at least two non-trivial systems
• Customer-facing products in production. You've built interfaces real users depend on, in TypeScript and React (or a clear path from a comparable stack), and owned the systems behind them
• Deep experience with data. You've worked across multiple database types (relational, document, KV, time-series, search, vector, etc.) and understand how the choice of data model shapes the system. Schema design, migrations, indexing, and performance are second nature regardless of the engine
• Deploying and operating backend systems in production. You've taken services from "runs on my machine" to "runs reliably for real users." Observability, failure modes, deploys, rollbacks, incident response. You've lived in the loop, not just consumed a managed service that hid it from you
• Built with agents, not just used them. You've designed an eval loop, shipped an agent that runs without someone watching, and can talk through the cost, latency, and failure trade-offs of its tool calls. Daily use of Claude Code or equivalent, with rules, skills, or MCP servers you wrote, is the starting point. You understand how Claude Code (or your harness) loads context: which CLAUDE.md files, rules, skills, and tool definitions land in the window, when, and what that costs.
• Skeptical of agent output. You review what an agent produces as critically as a teammate's PR, and you notice when it's confidently wrong
• Solution definition. Given a written problem, you shape a sound solution, name the risks early (rate limits, stale data, what happens when a dependency fails), and say plainly what you'd leave out

Bonus#

None of these are required. Equivalents are welcome; we care about the shape of the experience more than the specific tool.

• Platform experience: container orchestration (Kubernetes or similar), declarative infrastructure (Terraform, Pulumi, Crossplane, Helm), or GitOps (Flux, Argo)
• Long-running workflow orchestration (Temporal, Airflow, or custom) and event-driven architectures (NATS, Kafka, RedPanda, etc.)
• A backend language alongside TypeScript, such as Go, Rust, Elixir, Python, or Java
• Agent tooling beyond the defaults: Claude Code plugins or hooks you've written, work in other harnesses (OpenCode, Pi, or your own), or agents that run as durable background workers
• OSS contributions to agent tooling; MCP server development; Claude Code skill authorship
• Public writing on agentic practice or engineering craft

Technologies We Use and Teach#

We're pragmatic about stacks: the right tool for the context. You don't need to know all of these on day one; we teach what you don't.

Agentic Layer#

Claude Code, MCP, and the Claude Agent SDK are daily tools, and we extend Claude Code with our own plugins, mods, and hooks. We use other harnesses where they fit, and we run durable agent workers on our own infrastructure: Temporal-backed workers that clone a repo, run an agent headless, and post results back for a person to review. We invest heavily in durable team judgment, encoded as skills, rules, subagents, and reusable patterns across our projects.

Application Layer#

TypeScript, React, and the frameworks that fit the project. Tailwind and shadcn/ui for UI, TanStack Query for client state, Vitest and Playwright for tests, Biome for tooling. PostgreSQL as our default relational database. Other backend languages are welcome: Go, Rust, Python, and Elixir all show up in our work.

Platform & Deployment#

Client-owned infrastructure when that serves the client (including Canadian data residency), hyperscalers when context demands it. Where an engagement fits, we use Kubernetes, GitOps, Temporal, and OpenTelemetry.

Why You'll Love Working at Rangle#

• AI-native by default. Claude Code and agent orchestration aren't side experiments here; they're how you ship. You use them daily, and you build the patterns the rest of the team picks up.
• Products people use. You ship customer-facing software for enterprise clients, into production, with real users on the other end.
• Flight time, not seniority theater. We track reps and capability, not titles. Structured coaching moves strong ASEs toward AMD in ~18 months when the growth is real.
• Meta-system leverage. The internal tools, rules, and patterns you build flow across projects. A skill you write for one client unblocks three more.
• Small, high-trust teams. You know your colleagues and they know you. Accountability is earned, not performed.
• Client exposure without commercial weight. You're in the architecture conversations without carrying the P&L of the AMD.
• Frontier technology, production discipline. We use the newest stuff. No vibes-only demos.