About us

We’re building toward a world where every company can become its own AI lab.

Goaly is a stealth AI startup founded by ex-Meta Superintelligence Labs engineers and researchers. Our mission is to dramatically lower the cost, time, and talent barriers to building proprietary AI — and make each generation of models faster and cheaper to build than the last.

Backed by leading AI investors and endorsed by frontier AI researchers and builders, we’re looking for exceptional new grads who want to work on hard, foundational AI systems problems with outsized ownership from day one.

About the role

You will be one of the first engineers building the layer between frontier models and real users: the agent harness. That means the loop, the tools, the context, the sandbox the agent runs in, and the evals that tell us whether it actually works. You will ship this into production for real customers, then turn what we learn from those runs into better environments, better evals, and better models.

This is a founding role. There is no playbook yet; you help write it. You will own problems end to end, from the first prototype with a customer to a system that runs thousands of agent rollouts a day without anyone watching it.

What you'll do

Own the harness: the agent loop, tool interface, system prompts, permissions, stop conditions, retries, budget caps, and output checks that turn a model into a dependable agent.

Build sandboxed execution environments (containers / microVMs) that are isolated, reproducible, and fast enough to run thousands of rollouts in parallel, used both for serving and for RL and evals.

Design context engineering: what goes into the window, when to compact, file-backed memory and state, retrieval, and hand-offs between sub-agents on long-running tasks.

Make every agent run observable and replayable: trace every model call, tool call, and state change, so a failure at 3am can be reproduced at 9am.

Build the eval stack: offline suites, tests on production traces, LLM-as-judge, and checks that catch reward hacking and silent failures before they poison training data.

Ship with customers: embed with real users, take a workflow from prototype to stable production, and turn repeated patterns into reusable building blocks (tools, MCP servers, agent skills, playbooks).

Close the loop with research: convert production traces and failures into tasks, environments, and reward signals for post-training.

Make the model calls: pick which model runs where, and own the cost, latency, and quality trade-offs.

You may be a good fit if you have

5+ years building production software, with real experience running systems at scale (many users, high request volume, on-call scars).

Built and shipped an agentic system with tool use that real users depend on, and debugged it when it broke.

First-hand experience with the failure modes: context overflow, agents looping, tool misuse, prompt injection, runaway cost.

Strong Python plus at least one of TypeScript, Go, or Rust; comfortable with Docker, Linux, and cloud infrastructure.

A habit of building your own evals instead of trusting public benchmarks; you measure before you claim.

A strong pull toward the simplest system that works, and a low tolerance for complexity that does not earn its keep.

Comfort operating without a playbook, in ambiguity, and being wrong quickly in front of customers.

The ability to explain trade-offs clearly to engineers, researchers, and customers.

Strong pluses

Experience building agent platforms, workflow systems, model-serving products, ML infrastructure, or other developer-facing AI systems.

Experience with multi-tenant control planes, identity and access management, metering or billing, enterprise security, or high-throughput APIs.

Familiarity with LLM inference, fine-tuning, evaluation, tool use, sandboxes, or the operational lifecycle of production agents.

Experience owning open-source SDKs, developer tools, API documentation, examples, or community-facing integrations.

Full-stack ability and an eye for interaction design when a product problem requires work beyond the backend.