Notes from building an agent runtime.
Engineering deep dives, product updates, and field reports from running teams of AI agents in production.
Human-in-the-loop, without stalling the run
Approval gates and ask-for-input tools let an agent pause for a human and pick up exactly where it left off. A look at the pause/resume model behind it.
What counts as a workflow step (and why we meter it that way)
Usage-based pricing only works if the unit is honest. We break down what a step is, how it's measured, and how to keep runs predictable.
Debugging a multi-agent run like a stack trace
Per-step traces turn an opaque agent loop into something you can actually read. A walkthrough of the trace format and the questions it answers.
Bring your own connectors: Gmail and Salesforce in a workflow
Agents are only as useful as the tools they can reach. How BYO OAuth connectors let a crew act on your real systems, with tokens encrypted at rest.
Routing steps across models without rewriting your workflow
Not every step needs your most expensive model. How per-step model routing trims cost and latency while keeping the same workflow definition.
An agent hub: reusable roles across every workflow
Most teams rebuild the same planner, researcher, and reviewer in workflow after workflow. The Agent Hub turns a role you've tuned once into a building block you drop in anywhere.
Recurring runs: putting agent workflows on a schedule
Plenty of agent work is recurring — a morning digest, a nightly reconciliation, a weekly report. Schedules let a workflow run itself on a cron, no external trigger required.
What we shipped in 2025
A look back at a year that took LoopLlama from a sequential-crew runtime to a platform with connectors, human-in-the-loop, model routing, and the observability to run it all in production.
Bring your own tools with OpenAPI
An agent is only as capable as the tools it can call. Point LoopLlama at an OpenAPI spec and every operation in it becomes a typed tool your crew can use.
Webhooks and the async job model
Agent runs take seconds to minutes, which makes them a poor fit for a blocking request. A look at how we model runs as async jobs you can stream, poll, or subscribe to.
Typed SDKs for TypeScript, Python, and Go
The REST API has always been the source of truth. Now there are first-party, fully typed SDKs in three languages so you can call it without hand-rolling HTTP.
Why agents fail in production (and what we do about it)
Agent demos are dazzling and agent deployments are humbling. The failure modes are predictable, though — and most of them are operational, not intelligence problems.
The road to SOC 2: building trust from day one
Agents that act on your real systems demand real security. A look at the foundations — encryption, tenant isolation, least privilege — behind our SOC 2 effort.
Streaming agent progress: the event model
A multi-step run is opaque if all you get is the final answer. Streaming events make a run legible while it happens — here's the event model behind it.
LoopLlama is generally available
After a year of building with early users, the orchestration API for teams of AI agents is open to everyone. Here's what GA means and what's in it.
Tool standards are coming. Here's how we think about connectors.
An open protocol for connecting models to tools is emerging across the industry. A look at what it means for agent builders — and how LoopLlama's connector model fits.
Reasoning models change which step needs which model
A new class of models trades latency and cost for deeper reasoning. That makes the question 'which model runs this step?' more important than ever.
Structured outputs finally make tool calls reliable
Tool calling only works if the model returns arguments that actually match the schema. Guaranteed structured outputs close that gap — and they're a quiet turning point for agents.
Frameworks are great for demos. Production needs a runtime.
Agent frameworks make it easy to wire a crew together on your laptop. Keeping that crew running reliably for real users is a different problem — and it's not a library problem.
Why we started LoopLlama
A single model call can do a remarkable amount. Real projects need more than one — coordinated, stateful, observable. That gap is why we started LoopLlama.
Get new posts in your inbox
Occasional updates on the product and what we're learning. No spam.
Subscribe