How Loop Engineering Is More Powerful Than Prompt Engineering

Loop Engineering is an emerging approach to building AI systems that repeatedly act, observe results, evaluate progress, and decide what to do next until a goal is reached or a stopping condition is triggered. Instead of asking a human to write the next prompt after every AI response, the developer designs the system that determines the next action.

That sounds like a small change. It is not.

Prompt engineering improved how humans communicate with language models. Context engineering improved what information models receive. Agent harnesses added tools, permissions, memory, and execution environments. Loop Engineering moves one level higher by asking how these components should operate repeatedly over time.

The term gained serious attention in 2026 as coding agents and autonomous workflows became capable of working for longer periods without constant human supervision. Anthropic now describes loops as agents repeating cycles of work until a stop condition is met, while IBM defines Loop Engineering as designing agentic workflows that iteratively guide agents toward user-defined goals with minimal human intervention.

Yet the underlying idea has a much longer history. Modern agent loops inherit concepts from feedback control, autonomic computing, iterative software development, reinforcement learning, and earlier language-agent research. Understanding that lineage is important because reliable loops require far more than simply telling an AI model to “keep trying.”

What Is Loop Engineering?

Loop Engineering is the practice of designing controlled, repeatable AI-agent workflows in which an agent acts, receives feedback, evaluates its progress, and continues or stops according to explicit rules. The central engineering problem is therefore not merely generating a good prompt. It is designing a reliable feedback system around the model.

A basic loop might look like this:

Goal
  ↓
Context
  ↓
Agent Action
  ↓
Environment / Tool Result
  ↓
Verification
  ↓
Decision
  ├── Success → Stop
  ├── Failure → Revise and Repeat
  └── Uncertain → Human Escalation

The distinction matters because a language model can generate plausible output without knowing whether that output actually solved the problem. A loop closes that gap by bringing the result back into the system.

Consider a coding agent. An open-ended prompt might say:

Fix the login bug.

The model could edit the code and declare success.

A properly designed loop instead asks the agent to inspect the problem, modify the code, run tests, examine failures, revise the implementation, rerun verification, and stop only after the required conditions pass.

The intelligence does not come only from the model. Part of it comes from the structure surrounding the model.

Loop Engineering Is New, but Feedback Loops Are Not

Loop Engineering is best understood as a new engineering abstraction built on much older ideas.

In 2003, research around IBM’s autonomic computing vision described systems capable of monitoring themselves, diagnosing problems, planning corrective actions, and executing those actions with reduced human intervention. This work contributed to what became widely known as the MAPE-K model: Monitor, Analyze, Plan, Execute, over shared Knowledge. The purpose was to create self-managing software systems capable of responding to changing environments.

Conceptually, the resemblance to modern AI loops is striking:

Autonomic Computing	Modern Agent Loop
Monitor	Observe tool/environment state
Analyze	Reason about the result
Plan	Select the next action
Execute	Call a tool or modify the environment
Knowledge	Context, memory, state
Feedback	Verification and next iteration

Loop Engineering therefore does not invent feedback control. Its novelty comes from applying feedback-oriented system design to LLM-based agents whose decisions are probabilistic, language-mediated, tool-using, and increasingly autonomous.

This distinction is important. Calling every repeated AI prompt “Loop Engineering” makes the concept almost meaningless. Engineering begins when the loop has explicit goals, state, verification, budgets, permissions, failure handling, and termination logic.

How Does Loop Engineering Work?

A useful way to think about Loop Engineering is through six stages:

The LayersPilot Agent Loop

GOAL → CONTEXT → ACT → VERIFY → DECIDE → REPEAT / STOP

Each stage solves a different engineering problem.

Goal

The system first needs a definition of success.

“Improve this website” is a poor loop goal because the system cannot objectively determine when the task is complete.

A stronger goal might be:

Resolve all broken internal links discovered in the crawl, introduce no new 4xx responses, and stop after verification passes or five repair attempts.

The clearer the end state, the easier it becomes to build reliable termination logic.

Context

The agent needs enough information to make the next decision.

Context can include source code, documentation, previous actions, database records, test output, user preferences, policies, tool responses, or persistent state from previous iterations.

Too little context creates blind decisions. Too much context creates noise, cost, and potentially context drift.

This is why context engineering remains part of Loop Engineering rather than being replaced by it.

Act

The agent performs an action.

That action might involve:

• editing code
• querying a database
• browsing documentation
• generating a report
• replying to a support message
• changing a configuration
• running a test
• calling an API

The model becomes operational only when reasoning is connected to an environment.

Verify

Verification is one of the most important parts of a serious loop.

The system needs evidence that the action worked.

For coding, verification may come from unit tests, compilation, static analysis, or browser tests. For SEO automation, it may come from structured checks against page requirements. For a customer-support workflow, policy rules and confidence thresholds may determine whether a response is safe to send.

Verification transforms an agent from a generator into part of a controlled process.

Decide

The system evaluates the evidence and decides whether to:

continue, revise, retry, escalate, or stop.

This is where a loop differs from a fixed automation pipeline. The next action can depend on what happened during the previous iteration.

Repeat or Stop

A good loop must know when to finish.

Anthropic specifically emphasizes clear success and stop criteria when designing loops because poorly bounded agentic work can continue consuming resources without producing proportional value.

A production loop should usually have more than one stopping mechanism:

Stop if:
✓ Goal is satisfied
✓ Verification passes

Escalate if:
! Confidence is too low
! Permission is required
! Unexpected state occurs

Abort if:
✗ Maximum iterations reached
✗ Token or monetary budget exceeded
✗ Maximum execution time exceeded
✗ Same failure repeats

What Is an AI Agent Loop?

An AI agent loop is the repeated cycle through which an agent observes its state, decides what action to take, performs that action, receives new information, and decides what to do next.

Loop Engineering is broader.

It is the discipline of designing and controlling that loop.

Concept	What It Means
AI model	Generates predictions or responses
AI agent	Uses a model to reason and take actions
Agent loop	Repeated observe-decide-act cycle
Agent harness	Tools, permissions, runtime, context and constraints surrounding the agent
Loop Engineering	Design of the complete repeated workflow, including triggers, state, verification, budgets and stopping conditions

This distinction matters because nearly every useful autonomous agent eventually requires some form of iteration.

A 2026 survey of agent-loop design argues that reliability, cost, termination, verification and safety cannot be understood by examining the model alone. They emerge from the larger control loop in which the model operates.

Loop Engineering vs Prompt Engineering

The simplest distinction is this:

Prompt Engineering optimizes what you tell the AI. Loop Engineering optimizes the system that decides what the AI should do next.

Prompt engineering remains useful. It simply operates at a lower level of abstraction.

Area	Prompt Engineering	Loop Engineering
Primary object	Prompt	Workflow
Main concern	Quality of instruction	Reliability of repeated execution
Human involvement	Usually frequent	Can be substantially reduced
Iteration	Often manual	Programmatic or agent-controlled
Tool use	Optional	Frequently central
Memory/state	Optional	Often necessary
Verification	Often human	Designed into workflow
Stop condition	Human usually decides	Explicit system rule
Failure recovery	New human prompt	Retry, revise, route or escalate
Best suited for	One-off tasks	Multi-step or recurring tasks

Is Prompt Engineering Dead?

No.

A loop still contains prompts.

The difference is that a human may no longer write each one interactively. Templates, policies, skills, state, previous results, or another agent can determine the prompt used during the next iteration.

Prompt quality therefore remains important, but it becomes one component of a larger engineered system.

A weak prompt inside a good loop can still cause problems. A brilliant prompt inside an uncontrolled loop can cause even bigger ones.

From Prompt Engineering to Context, Harness and Loop Engineering

The evolution of AI application design can be understood as a gradual expansion of what engineers control.

Prompt Engineering

Question: What instruction should the model receive?

The focus is wording, examples, constraints and desired output.

Context Engineering

Question: What information should the model have available when making the decision?

This includes retrieved documents, conversation history, state, user data, code, tool results and task-specific knowledge.

Harness Engineering

Question: What environment should surround the model?

The harness determines which tools the agent can access, what permissions it has, how execution works, how state is stored, and which safeguards constrain its behavior.

Loop Engineering

Question: What should happen repeatedly until the objective is satisfied?

Loop Engineering coordinates the other layers across time.

Prompt
   ↓
Context
   ↓
Harness
   ↓
Loop
   ↓
Long-running agentic system

These layers should not be treated as competing buzzwords. A production agent may depend on all four simultaneously.

The Academic Roots of Modern Agent Loops

Modern Loop Engineering did not emerge from nowhere.

One important predecessor is ReAct, introduced in 2022 and published at ICLR 2023. ReAct combined reasoning and action in an interleaved process, allowing language models to reason about a problem, take actions in an external environment, observe new information, and update their plans. The research showed that interacting with an environment could reduce problems such as hallucination and error propagation compared with reasoning in isolation.

Another important step was Reflexion, published at NeurIPS 2023. Instead of modifying model weights after a failure, Reflexion used linguistic feedback and episodic memory to help an agent reflect on previous attempts and improve subsequent ones. In the paper’s HumanEval experiment, Reflexion reported 91% pass@1 compared with the cited GPT-4 baseline of 80%.

The conceptual progression is revealing:

Prompt
   ↓
Reason
   ↓
Act
   ↓
Observe
   ↓
Reflect / Verify
   ↓
Update Context
   ↓
Act Again

What practitioners now call Loop Engineering packages these iterative behaviors into a broader engineering discipline focused on reliable operation, orchestration, cost, stopping, memory and governance.

Types of AI Agent Loops

Not every loop behaves in the same way.

Anthropic currently distinguishes several practical patterns, including turn-based, goal-based, time-based and proactive loops. LangChain similarly describes multiple loop layers, including core agent loops, verification loops, event-driven loops and improvement-oriented loops.

Turn-Based Loops

A human initiates the task.

The agent may perform several internal actions before returning an answer.

These loops suit exploratory work where human judgment remains frequent.

Goal-Based Loops

The agent works until an explicit condition becomes true.

For example:

Goal:
Fix failing tests.

Stop when:
All required tests pass.

Maximum:
5 attempts.

This is one of the most powerful patterns because “done” can be machine-checked.

Time-Based Loops

The workflow executes on a schedule.

Examples include:

• summarize new issues every morning
• check a deployment every 15 minutes
• analyze new support requests hourly
• review ranking changes once per day

Anthropic’s Claude tooling now exposes scheduled and interval-based loop patterns for this type of work.

Event-Driven Loops

An external event starts the process.

The trigger might be:

New GitHub issue
New customer email
Failed CI pipeline
New document
New lead
Inventory threshold reached

These loops often provide better efficiency than continuously polling a system.

Verification Loops

One agent or deterministic system produces work while another check determines whether it satisfies the specification.

A coding example might use:

Generate → Compile → Test → Inspect → Fix → Test Again

The verifier creates the feedback signal.

Improvement Loops

Some systems evaluate previous executions and modify prompts, context, routing rules, skills, or strategies for future runs.

These loops move beyond completing one task. They try to improve the process used to complete future tasks.

Core Components of Reliable Loop Engineering

A loop that repeatedly calls an LLM is easy to build.

A loop that is reliable, bounded, economical and safe is much harder.

Machine-Checkable Success

Whenever possible, success should be externally verifiable.

“Looks good” is weak.

“All 52 tests pass and no lint errors remain” is stronger.

A recent study of agentic planning illustrates why external grounding matters. In a controlled planning experiment, agentic step-wise interaction produced only a modest improvement over direct LLM planning while consuming substantially more tokens. The authors argue that coding agents often benefit more because compilers and tests provide stronger external feedback than self-assessed planning states.

That observation has major implications for Loop Engineering:

More iteration does not automatically create more intelligence. The quality of the feedback signal matters.

Persistent State

Long-running loops need to remember what has already happened.

State may include:

• completed steps
• attempted solutions
• previous errors
• unresolved tasks
• resource consumption
• checkpoints
• user decisions

Without state, the agent risks repeating work or losing the original objective.

Tools and Connectors

Loops gain practical value when agents can interact with real systems.

Examples include:

APIs, browsers, command lines, databases, Git repositories, CRM platforms, search tools, messaging systems and MCP-connected services.

Tool access also increases risk, which makes permission boundaries essential.

Verification

The strongest verifier is often not another free-form model response.

Prefer deterministic evidence where available:

Compiler
Unit test
Schema validator
Database constraint
HTTP status
Business rule
Numerical threshold
Security policy

LLM judges can still help when subjective evaluation is unavoidable, but verification architecture should reflect uncertainty.

Budgets

Every loop should have resource boundaries.

Useful budgets include:

• maximum iterations
• maximum elapsed time
• maximum tokens
• maximum monetary cost
• maximum tool calls
• maximum failed attempts

A system that can continue indefinitely is not autonomous in a useful sense. It is uncontrolled.

Human Escalation

Autonomy should not mean removing humans from every decision.

Some conditions should intentionally return control:

Low confidence
Sensitive financial action
Permission change
Security-sensitive operation
Repeated failure
Unexpected environment
Irreversible action
Policy ambiguity

The ability to stop and ask for help is often a sign of a better-engineered agent, not a weaker one.

Real-World Loop Engineering Examples

Loop Engineering becomes easier to understand when applied to actual workflows.

AI Coding Loop

A coding loop could operate as follows:

Issue received
      ↓
Inspect repository
      ↓
Identify likely cause
      ↓
Modify code
      ↓
Run tests
      ↓
Tests fail?
   ↙       ↘
 Yes       No
 ↓          ↓
Inspect    Review diff
failure       ↓
 ↓        Create PR
Revise
 ↓
Repeat

This type of workflow works particularly well because software development produces strong feedback signals: test output, compiler errors, linting, runtime behavior and code review.

Modern coding-agent ecosystems increasingly expose primitives for goals, worktrees, persistent state, verification and scheduled execution. Anthropic’s current guidance similarly recommends defining what “done” means, setting budgets and piloting loops before allowing larger executions.

SEO and Content Loop

Loop Engineering can also support SEO, although publishing should retain human review.

A practical workflow might be:

Target query
   ↓
Collect SERP evidence
   ↓
Identify search intent
   ↓
Build content brief
   ↓
Draft section
   ↓
Check factual support
   ↓
Check intent coverage
   ↓
Check internal links
   ↓
Human editorial review
   ↓
Publish

The important part is not making AI write faster.

The important part is creating gates that prevent weak work from moving forward simply because an AI model generated it.

Customer Support Loop

A customer-care system could follow:

New message
   ↓
Classify intent
   ↓
Retrieve customer + policy context
   ↓
Draft response
   ↓
Policy check
   ↓
Confidence check
   ├── Safe → Send / Queue
   └── Uncertain → Human agent
   ↓
Store outcome

The loop is valuable because verification and escalation are designed before automation begins.

Website Monitoring Loop

A monitoring agent might:

Check site
   ↓
Detect failure
   ↓
Collect logs
   ↓
Diagnose
   ↓
Attempt approved fix
   ↓
Retest
   ↓
Recovered?
   ├── Yes → Record resolution
   └── No → Escalate

Again, the architecture matters more than the prompt.

How to Build Your First Loop Engineering Workflow

The best first loop is usually small, repetitive, measurable and reversible.

Step 1: Choose a Narrow Task

Do not begin with:

Run my entire company.

Start with:

Check new bug reports every hour and classify each as duplicate, reproducible, or requiring human review.

Narrow loops are easier to test.

Step 2: Define What Success Means

Write the stopping condition before writing the agent instructions.

If you cannot define “done,” your agent cannot reliably know when to stop.

Step 3: Define the Available Context

Specify exactly what information the agent can see.

Avoid dumping every available document into every iteration.

Step 4: Restrict Tools

Give the agent only the permissions necessary for the task.

Read access does not automatically require write access.

Drafting an email does not automatically require permission to send it.

Step 5: Add Verification

Ask:

What external evidence would convince us that this action succeeded?

Build that evidence into the loop.

Step 6: Add Failure Handling

A production loop should expect failure.

For example:

Attempt 1 → failed
Attempt 2 → different strategy
Attempt 3 → failed
→ stop and escalate

Repeating the same failure ten times is not intelligent iteration.

Step 7: Track State

Record what the loop tried, what happened, and why it chose the next action.

This improves debugging and prevents repeated mistakes.

Step 8: Set Budgets

Define maximum time, token consumption, cost and retries.

Step 9: Run Under Human Supervision

Observe where the loop:

• stops too early
• fails to stop
• misreads feedback
• repeats actions
• uses unnecessary tools
• consumes excessive tokens
• escalates too often
• escalates too rarely

Only then should autonomy increase.

A simplified implementation can be represented as:

goal = define_goal()
state = initialize_state()
budget = define_budget()

while budget.remaining():

    context = build_context(state)

    action = agent.decide(context)

    result = execute(action)

    evidence = verify(result)

    state.record(action, result, evidence)

    if evidence.success:
        return SUCCESS

    if evidence.requires_human:
        return ESCALATE

    if repeated_failure(state):
        return ESCALATE

return BUDGET_EXCEEDED

The loop itself is simple.

Designing the goal, verifier, state, permissions and stopping logic is where most of the engineering difficulty lies.

Loop Engineering Risks and Failure Modes

More autonomy creates more leverage, but it can also amplify mistakes.

Infinite or Wasteful Loops

An agent may continue because the success condition is vague.

The result can be unnecessary API calls, token consumption and execution time.

False Verification

A dangerous pattern occurs when essentially the same model produces an answer and then confidently approves its own answer.

Independent tests or external evidence are preferable when available.

Context Drift

After many iterations, the agent may optimize for the most recent feedback rather than the original objective.

Persistent goal state and checkpoints help reduce this problem.

Repeated Failure

An agent may repeatedly attempt slight variations of a fundamentally wrong solution.

Good loops detect lack of progress rather than interpreting every additional attempt as useful exploration.

Cost Amplification

A single poor prompt wastes one inference.

A poor loop can waste hundreds.

Anthropic specifically recommends using cheaper models for simpler work, matching schedule frequency to actual need, and reviewing usage across agentic workflows.

Unsafe Autonomy

A loop with broad permissions can repeat harmful actions faster than a human can intervene.

High-risk operations need narrower permissions, checkpoints, approval gates and auditable logs.

Automation Bias

Perhaps the most subtle risk is human overconfidence.

Once a system works reliably several times, people may stop checking it. This is precisely when rare edge cases become dangerous.

A good principle is:

A successful loop is not the one that can run forever. It is the one that knows when to continue, when to stop, and when to return control to a human.

Is Loop Engineering Actually Being Used?

This question matters because new AI terminology often spreads faster than evidence.

A recent 2026 research paper provides one of the first empirical investigations of Loop Engineering adoption in software projects. The researchers analyzed 36,710 repositories, identified 256 candidate repositories using their heuristics, and confirmed autonomous agent loops in 217 of those candidates.

The result is significant because it shows that autonomous loop patterns are not purely theoretical.

However, the study also provides an important warning against hype. The authors found a gap between recommended Loop Engineering practices and what could actually be observed in repositories. For example, configuration around loops was commonly committed, while persistent runtime state described in practitioner guidance was rarely present in version control. The paper is exploratory and was listed as under review, so its findings should be treated as early evidence rather than the final measurement of industry adoption.

This is perhaps the most accurate description of Loop Engineering in 2026:

real, rapidly emerging, technically meaningful, but not yet a mature or standardized engineering discipline.

Loop Engineering in Claude

Claude has become closely associated with the term because Claude Code now exposes several practical loop patterns.

Anthropic categorizes loops according to how they start and stop:

Loop	Typical Trigger	Typical Stop Condition
Turn-based	User prompt	Agent finishes or requests context
Goal-based	Explicit objective	Goal condition satisfied
Time-based	Schedule or interval	Work complete or schedule cancelled
Proactive	Event or schedule	Individual task goal reached

Anthropic’s guidance emphasizes several principles that apply far beyond Claude: define success clearly, use appropriate models for the job, pilot workflows before scaling them, prefer deterministic scripts where reasoning adds no value, and monitor resource consumption.

So Loop Engineering in Claude is not a special form of Loop Engineering. Claude simply provides a practical environment in which several loop patterns can be composed.

Loop Engineering on GitHub

The growing developer ecosystem around Loop Engineering is also visible on GitHub.

Open-source projects now provide starter patterns, loop auditing, state management, cost estimation, worktree isolation and agent orchestration. The broader significance is not any single CLI tool. It is that developers are beginning to treat agent behavior as infrastructure that can be configured, versioned, tested and inspected.

That shift is important.

When prompts become part of loops, and loops become part of software systems, agent behavior starts looking less like casual conversation and more like an engineering artifact.

When Should You Use Loop Engineering?

Loop Engineering makes sense when several characteristics are present:

The task is multi-step.
One response is unlikely to complete it.

Progress can be observed.
The system receives meaningful evidence after each action.

Success can be defined.
There is a measurable end condition.

Failure can be detected.
The system knows when an attempt did not work.

The process repeats frequently.
Automating the coordination saves meaningful human effort.

Tool access creates leverage.
The agent can interact with a real environment.

A simple prompt remains better when the task is:

• one-off
• subjective
• inexpensive
• difficult to verify
• highly dependent on immediate human judgment

Building a six-agent autonomous loop to rewrite a three-sentence email is not advanced engineering. It is unnecessary complexity.

Is Loop Engineering the Future of AI Agents?

Loop Engineering is likely to become increasingly important as agents move from short conversations toward longer-running work.

But its future should not be framed as:

prompts versus loops.

A more accurate progression is:

prompts inside context, context inside harnesses, and harnesses operating inside controlled loops.

Modern agents increasingly need to operate across time, interact with external systems, recover from errors, verify outcomes and manage limited resources. Those requirements naturally turn feedback, state and termination into first-class engineering concerns.

The 2026 emergence of the Loop Engineering label therefore represents something deeper than another AI buzzword. It reflects a change in where developers are applying their effort.

The central question is shifting from:

What should I ask the model?

to:

What system should determine what the model does next, verify the result, and decide whether it should continue?

That is the core idea behind Loop Engineering.

Frequently Asked Questions About Loop Engineering

What is Loop Engineering in AI?

Loop Engineering is the practice of designing AI-agent workflows that repeatedly act, observe results, verify progress, and adjust their next action until a defined goal or stopping condition is reached. It moves the focus from individual prompts toward the complete control system surrounding an AI agent.

What is an agent loop?

An agent loop is the repeated cycle through which an AI agent observes its current state, chooses an action, interacts with a tool or environment, evaluates the result, and decides what to do next.

What is the difference between Prompt Engineering and Loop Engineering?

Prompt Engineering focuses on improving individual instructions given to an AI model. Loop Engineering focuses on designing the repeated workflow around an agent, including context, actions, tools, verification, memory, retry logic, budgets and stopping conditions.

Is Loop Engineering replacing Prompt Engineering?

No. Prompt Engineering remains useful because loops still depend on instructions. Loop Engineering operates at a higher level by deciding when prompts are generated, what context accompanies them, how results are checked, and what happens after each response.

What is Loop Engineering in Claude?

In Claude Code, Loop Engineering can involve turn-based, goal-based, scheduled and proactive agent workflows. These patterns allow Claude to repeat work until a goal is satisfied or another stopping condition is reached.

Does Loop Engineering require coding?

Not always. Low-code automation platforms and agent tools can create simple loops. However, production-grade loops usually require more technical work around APIs, permissions, state, observability, verification and error handling.

How do you stop an AI agent loop?

A loop can stop when its success condition passes, a retry limit is reached, a time or token budget expires, an unrecoverable error occurs, or the workflow determines that human intervention is required.

Is Loop Engineering safe?

Loop Engineering can be made safer through restricted permissions, deterministic verification, execution budgets, audit logs, checkpoints and explicit human-escalation rules. More autonomy should normally be accompanied by stronger controls.

Final Perspective

Loop Engineering is not simply “prompting in a loop.”

It is the engineering of feedback, state, verification, control and termination around AI agents.

Its roots can be traced through decades of feedback-oriented computing, from autonomic systems to modern language-agent research such as ReAct and Reflexion. What changed in 2026 is the abstraction level at which developers increasingly work. Powerful agents can now perform enough useful work that designing their operating loop has become a practical engineering problem rather than a theoretical possibility.

A useful mental model is:

GOAL → CONTEXT → ACT → VERIFY → DECIDE → REPEAT / STOP

If the goal is vague, the loop wanders.

If the context is poor, the agent acts blindly.

If verification is weak, failure looks like success.

If state is missing, the loop forgets.

If budgets are absent, autonomy becomes expensive.

If stopping conditions are undefined, iteration becomes drift.

And if human escalation is impossible, automation becomes risk.

The next generation of useful AI systems will therefore depend not only on better models or better prompts. It will depend on better control systems around those models.

That is what makes Loop Engineering worth paying attention to.

Looking to Build Smarter AI-Powered Workflows?

LayersPilot helps businesses combine web development, SEO, digital automation, and ongoing website support to create more effective online workflows.

Explore LayersPilot Services