Agent Builder

Aisle; New York (NY); On-site; USD 140,000 - 180,000; Full time

Job summary

Aisle builds a real-time control layer for physical retail, enabling brands to act in real time. We are hiring an Agent Builder to join our internal agent stack and work with our founding engineer to scale from 8 agents to a broader ecosystem.

You’ll focus on two areas: operator enablement—designing tooling, plugins, integrations, and workflows; and agent life-support systems—memory, prompts, context, retrieval, evals, and observability.

Qualifications

• Hands-on production experience with at least one agent framework (OpenAI Agents SDK, Claude Code, Codex, Cursor, OpenClaw, LangGraph, Hermes, or your own custom rig).
• Fluency with sessions, context windows, memory systems, tool/function calling, and MCP/ACP‑style harnesses.
• Prompting and context design as core craft; iterate until agent behavior is reliable.
• Outcomes-driven thinking; decompose tasks into agent-actionable steps with operators.
• Opinions on memory design, system prompts, and orchestration for agent systems.

Responsibilities

• Partner closely with domain experts and operators; distill tacit knowledge into agent capabilities.
• Own the agent's life-support systems: memory, system prompts, context windows, retrieval, eval loops, observability.
• Design and build background tools, plugins, and skills to expand agent capabilities.
• Keep production systems healthy; diagnose misbehavior and fix underlying patterns.
• Run experiments to measure impact and determine next fixes.
• Develop and share reusable patterns for memory, prompting, context, tooling, and orchestration.

Skills

Agent framework experience

Memory systems design

Context windows management

Prompt design

Tool/function calling

Architectural thinking

Operational debugging

Tools

OpenAI Agents SDK

OpenClaw

Hermes

LangGraph

Cursor

Job description

About the Role

Physical retail has always been a black box - brands ship product, run static promotions, and wait weeks (or months) to understand what actually happened.

Aisle builds a real-time control layer on top of physical retail. We connect shopper actions, incentives, and outcomes into a continuous feedback loop, so brands can trigger, measure, and optimize retail performance while it’s happening - not after the fact.

This is the foundation for autonomous retail execution: systems that don’t just report on what happened, but actively decide what should happen next - which offers to show, when to show them, and how to maximize outcomes in real time.

Today, 1600+ brands and 5M+ consumers use Aisle to drive measurable results in brick-and-mortar. Under the hood, that means high-volume event ingestion, real-time decisioning, and infrastructure that has to be both reliable and low-latency to influence behavior in the moment.

We’ve gotten here with a small, fast-moving team, and now we’re scaling the system to handle significantly more volume, complexity, and automation - including our agent systems that are now an integral part of our future.

We’re hiring an Agent Builder to work alongside our founding agent engineer on our internal agent stack — currently 8 agents (Reggie + the rest of the family) plus the plugin ecosystem around them. Built on OpenClaw, but any production agent harness experience (Hermes, custom rigs, etc.) translates directly.

You’ll split your time across two things:

1. Operator enablement. Sit with operators across the team, learn their workflows, and figure out what an agent should take off their plate. Design and ship the tooling that makes it happen — tools, skills, plugins, integrations, whatever the workflow needs.

2. Agent life-support systems. The general-purpose layer that makes every agent better: memory, system prompts, context management, retrieval, evals, observability, model routing. This is the substrate; it's not tied to any one domain or operator.

What You'll Do

• Partner closely with domain experts and operators — work alongside them, distill their tacit knowledge, and translate it into agent capabilities they actually use
• Own the agent's life-support systems — memory, system prompts, context windows, retrieval, eval loops, observability
• Design and build background tools, plugins, and skills that expand what our agents can do
• Keep the system healthy in production — diagnose where agents misbehave and fix the underlying patterns, not just the symptoms
• Run experiments to figure out where agents help or hurt — define rubrics, read traces, decide what to fix next
• Develop and share patterns — distill what works across the stack into reusable patterns for memory, prompting, context, tooling, and orchestration. Bring new model capabilities and design patterns to the team before we ask.

What You'll Need

Agent fluency

• Required: hands‑on production experience with at least one agent framework (OpenAI Agents SDK, Claude Code, Codex, Cursor, OpenClaw, LangGraph, Hermes, or your own custom rig). You've already built and shipped agents people actually use, and you know their failure modes by heart.
• You are fluent in sessions, context windows, memory systems, tool/function calling, and MCP/ACP‑style harnesses, even if someone else helped write the first version.
• Prompt + context design is a core craft for you, not a side hobby; you iterate ruthlessly until the agent’s behavior is reliable.
• You think in outcomes — you can sit with an operator, watch them work, and decompose their job into things an agent can actually do
• You have opinions on the substrate: memory design, system prompt architecture, context management, retrieval, evals — and you've shipped these for an agent that someone actually uses

Technical comfort (floor, not ceiling)

• You are comfortable in a terminal and can change configs, run scripts, restart services, and read logs — but you don't need to identify as a ‘full stack engineer.’
• You can wire up tools and plugins by following good docs and examples
• You can work alongside engineers when something needs real code changes, and you know when you’re out of your depth.

How you think (this matters more than your resume)

• 80/20 instincts in both directions — you know which 20% of features deliver 80% of the value, and you know the 20% of things agents do badly and design harness-level patterns to compensate
• Architectural thinking — you can think of agent systems as systems, hold the full anatomy in your head, and design changes with the ripple effects in mind
• You are just as happy debugging a weird trace in the OpenClaw TUI as you are talking to a human about why the agent feels ‘off.’
• Outcome-oriented: you care about what the agent accomplishes, not how many lines you wrote
• Strong problem decomposition and orchestration — you break gnarly tasks down into things an agent can actually do
• Token minimization mindset: efficiency over brute force
• Strong user-perspective thinking — what does the human actually want here?
• Introspective, process-oriented, low ego, collaborative

Nice to Haves

• Contributions to Openclaw or other agent/dev tool ecosystems
• Background in CPG, retail tech, or marketing platforms