Agent Builder

About the Company

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—such as 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, this means high-volume event ingestion, real-time decisioning, and infrastructure that must be both reliable and low-latency to influence behavior in the moment. We’ve achieved this with a small, fast-moving team and are now scaling the system to handle significantly more volume, complexity, and automation—including our agent systems that are now integral to our future.

About the Role

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 key areas:

• 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, or whatever the workflow needs.
• Agent life-support systems: The general-purpose layer that makes every agent better: memory, system prompts, context management, retrieval, evals, observability, and model routing. This is the substrate; it’s not tied to any one domain or operator.

Responsibilities

• 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, and 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, and 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.

Requirements

Agent Fluency

• 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.
• 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)

• 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.’
• Can wire up tools and plugins by following good docs and examples.
• 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.
• 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.