Agent Builder

BAM Ventures; New York (NY); On-site; USD 140,000 - 190,000; Full time

Job summary

Aisle in New York is seeking an Agent Builder to join our internal agent stack, currently 8 agents with a plugin ecosystem. You’ll work with our founding agent engineer on production-ready agent capabilities and life-support systems built on OpenClaw.

You’ll design tooling for operators, manage memory and prompts, and drive experiments to improve agent reliability and performance across the stack.

Qualifications

• Hands-on production experience with at least one agent framework (e.g., OpenAI Agents SDK, Claude Code, Codex, Cursor, OpenClaw, LangGraph, Hermes, or similar).
• Familiarity with sessions, context windows, memory systems, and tool/function calling.
• Strong prompt design and context management skills.
• Ability to decompose operator tasks into agent capabilities and design reusable patterns.

Responsibilities

• Partner with domain experts and operators to translate tacit knowledge into agent capabilities.
• Own and improve agent life-support systems: memory, prompts, context windows, retrieval, eval loops, observability.
• Design and build background tools, plugins, and skills for agent expansion.
• Maintain system health in production by diagnosing and fixing root causes, not just symptoms.
• Run experiments to measure impact and refine agent behavior.
• Develop and share reusable patterns across memory, prompting, context, tooling, and orchestration.

Skills

Agent frameworks

Context management

Memory systems

Tool calls

Prompt design

Operator collaboration

Architectural thinking

Experimentation

Debug traces

Decomposition & orchestration

Token minimization

User perspective

Collaboration

Tools

OpenClaw

Hermes

Job description

What is Aisle?

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.

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 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