Agents as a Service

Organizations of the future won't run with one agent. They will have thousands of them.

Scalable, observable, and auditable enterprise AI

Download now

Open source (Apache-2.0)

A Sleeper Service job: the agent version that ran, its tokens and cost, payload, and outputA Sleeper Service job: the agent version that ran, its tokens and cost, payload, output, feedback, delegation tree, and event log

Innovation is employees building their own agents. Risk is doing it without a central platform.

Every department has experts in their domain. These operators know their processes—where data is stored, what decisions need to be made, and what output is expected. Automating those processes is what allows an organization to scale.

Don't build automations without establishing the sandboxes in which they run.

Centralize agents. Decentralize orchestration.

When every vendor has AI built in, or when employees build their own harnesses, an organization will end up with the situation where the same question gets different answers. Asking a Salesforce Agentforce AI and a Xero AI the same question will yield different answers if each system has different data or different business logic.

Everything is a function that can be distilled as follows:

Input → Analysis → Output

Repeatable, not autonomous.

Each agent makes one decision or takes one action per invocation.

Specialization is training people to perform specific tasks rather than training everyone to do every task. That paradigm is the same with AI. Identify the best model for a task and provide it the instructions needed to most effectively deliver the desired output. Use any model on a per-agent basis. Anthropic, OpenAI, Google, and OpenRouter are all built in.

Agents list: each agent's description, options, current version, jobs this week, and spend against its limit

Centralize the agents and call them from anywhere.

n8n, Airflow, Temporal, cron, a vibe-coded app—anything that can make an HTTP request can leverage your specialists.

An agent's invoke keys for an n8n workflow and a webhook event source that turns market events into jobs

AI becomes an operational multiplier with event-driven processes (e.g. new support ticket, bank deposit, stock price move).

The CI Everywhere paradigm is plugging agents in wherever possible to take a first pass on tasks and only escalate to people when necessary.

Agents can work alone or can call other agents, with permissions, depth limits, and the full coordination tree logged.

A job's delegation tree, where risk-analyzer called notifier, and its event log

Unleash your people on your hardest problems. Solve the repetitive problems with AI.

Knowledge, learning, and evals

A pending memory change learned from feedback, awaiting the owner's approval next to its gating eval score

Knowledge

Every agent inherits the instructions provided above it—each layer getting more specialized.

Organizational Instructions → Agent Instructions → Agent Memory

Learning

When an agent receives feedback, it updates its own memory—never its instructions. Every memory change can require one-click approval from the agent's owner, with the eval score shown right next to it.

Evals

An agent can make multiple good decisions a second. It can also make multiple bad decisions a second if not carefully monitored.

You can A/B test the effectiveness of the instructions by creating a new version of an agent and running the eval against the new prompt or model. Promote the winner. Roll back if it regresses.

Every agent gets an eval suite. It runs automatically on every memory change, and on demand before you promote a new prompt or model. Any regression alerts the agent's owner. Orchestrate runs in order to catch model drift.

Observable and auditable

Don't wonder what your agents have done. See exactly what they have done.

Every edit to an agent creates an immutable version, and every job records exactly which version ran.

Every job records its tokens and cost. Every agent has a monthly budget it can't exceed.

Every invocation, every response, and everything between is logged. Any answer an agent gives or action an agent takes is fully traceable.

Dashboard: live agents, weekly jobs and success rate, monthly spend, jobs and tokens per day, and recent jobs with their cost
Download

Your agents. Your infrastructure.

Open source. Self-hosted. Your data. Your control.

Install

git clone https://github.com/willjohnson/sleeper-service.git && cd sleeper-service
cp .env.example .env
docker compose up -d
docker compose exec api sleeper init
docker compose exec api sleeper seed-models
  • .env — set secrets + a provider API key
  • sleeper init — prints your API key
  • sleeper seed-models — register starter models

Create an agent

curl -X POST localhost:8000/v1/agents \
  -H "Authorization: Bearer $SLEEPER_KEY" \
  -d '{"team_id": "…", "name": "risk-analyzer", "description": "Assesses business risk"}'

Run a job (after adding a version with a model + prompt — see Quickstart)

curl -X POST localhost:8000/v1/agents/$AGENT_ID/jobs \
  -H "Authorization: Bearer $SLEEPER_KEY" \
  -d '{"context": {"prompt": "AAPL dropped 6% in 20 minutes"}}'
Download on GitHubDocsWhy I built it

Apache-2.0. Free forever. Star it, fork it, break it.