Sign Up Sign In

AIGears

Alpha release

Stateful primitives for AI agents

An agent can agree to renew a certificate next Tuesday, or to wait while a manager approves a refund. When its session ends, that commitment is lost. AIGears keeps it and acts on it at the right time, so your team doesn't have to build and run that plumbing.

Start free Read the docs

Free tier, no credit card. Works over MCP and REST.

One agent session, and what happens after it ends
  1. Agent session ends
  2. Deadline reminder emailed
  3. Refund approved by finance
  4. Vendor status changed
  5. Webhook fired, 200

Every team shipping agents ends up building this.

It starts as a cron job and a database table. Then a webhook fails overnight and you add retries. A reminder goes out twice and you add idempotency keys. Someone in finance asks who approved a refund and you add an audit log. None of it is difficult, but it is now a service your team owns and gets paged for, and that time comes out of the agent itself.

Run a task later
What you'd build and run
A cron job or delayed queue, a worker that survives deploys, and retry logic.
With AIGears
schedule_create with a timestamp or a cron expression.
Keep track of a deadline
What you'd build and run
A table, a daily job that scans it, and reminder emails for each stage.
With AIGears
deadline_remember with the reminder steps you want.
Get sign-off before acting
What you'd build and run
Signed links, a review page, timeouts, and a record of every decision.
With AIGears
approval_request and we email the approver a single-use link.
Notice when something changes
What you'd build and run
A poller, stored snapshots, diffing, per-domain rate limits, and robots.txt checks.
With AIGears
watch_create with a URL and a match rule.
Deliver and account for all of it
What you'd build and run
Webhook signing, retries with backoff, a dead-letter queue, and logs someone can search.
With AIGears
Included with every tool.

What stays on your side is small: make the call, then check the signature on the webhook when it arrives.

Four tools for the things agents can't do alone

Each one is an MCP tool and a REST endpoint. They share the same webhook delivery, idempotency keys and audit log, so after you integrate one, the other three work the same way.

Scheduled callbacks

Run work later without running a scheduler.

The agent registers a webhook with a time, or with a cron expression and a timezone. We call it when it's due, whether or not the agent that created it is still running. Use it for follow-ups, weekly reports, renewals, or anything an agent says it will do later.

  • One-off or recurring, in any IANA timezone
  • Idempotency keys, so a retried request never schedules twice
  • Delivery history for every run

Next five runs 0 9 * * MON, Europe/Paris

5 Oct 07:00
12 Oct 07:00
19 Oct 07:00
26 Oct 08:00
2 Nov 08:00

Always 09:00 in Paris. Below the line is the time in UTC: it moves from 07:00 to 08:00 when the clocks go back on 25 October (dashed line).

Show the call
POST /v1/schedules/
curl -X POST https://aigears.net/v1/schedules/ \
  -H "Authorization: Bearer $AIGEARS_API_KEY" \
  -d '{
    "recurrence": "0 9 * * MON",
    "recurrence_tz": "Europe/Paris",
    "webhook_url": "https://api.yourapp.com/hooks/weekly-report",
    "payload": { "job": "compile_weekly_report" }
  }'

Deadline memory

Keep track of dates that outlive the conversation.

When an agent learns about a contract renewal or a filing date, it records it here. Any later session, or another agent on the same team, can ask what's due and get an answer. Reminders go out on the schedule you set: to the agent by webhook, to a person by email, or to both.

  • Default reminders 30 days, 7 days and 1 day before, on the day, then daily when overdue
  • Query by date window and tags
  • Agents can complete, snooze or cancel what they recorded

Renew ACME contract Due

  1. 30 days before: email
  2. 7 days before: email and webhook
  3. Due
  4. Overdue: webhook, then daily until it's completed
Show the call
deadline_remember
deadline_remember({
  "summary": "Renew ACME contract before auto-expiry",
  "due_at": "2027-03-14T00:00:00Z",
  "tags": ["contracts"],
  "notify_emails": ["[email protected]"],
  "webhook_url": "https://api.yourapp.com/hooks/deadlines",
  "escalation_policy": { "steps": [
    { "offset": "-P30D", "channels": ["email"] },
    { "offset": "-P7D", "channels": ["email", "webhook"] },
    { "offset": "P1D", "channels": ["webhook"], "repeat": "daily" }
  ]}
})

Approval gates

Put a person in front of risky actions.

Refunds, deletions and customer emails are where an autonomous agent's mistakes get expensive. The agent describes what it wants to do and waits. The approver gets a single-use link by email, reads the full request on a hosted page, and approves or rejects it. The agent gets the answer by webhook or by polling.

  • Requests expire after a timeout you set, from one minute to 30 days
  • Approvers can add a comment to their decision
  • Each decision is logged with who made it, when, and from which IP
Approval request 23 h 12 min left

Refund customer #4821: $1,250.00

Order ord_55310 was charged twice on 3 June.

Approver
[email protected]
Timeout
24 hours
Show the call
approval_request
approval_request({
  "approver_email": "[email protected]",
  "action_summary": "Refund customer #4821: $1,250.00",
  "action_details": "Order ord_55310 was charged twice on 3 June.",
  "timeout": "PT24H",
  "callback_url": "https://api.yourapp.com/hooks/approvals"
})
// returns { "id": "01JXK2F7…", "status": "pending" }

Watch-and-notify

Find out when a page, feed or API changes.

Agents can fetch a URL once, but they can't keep checking it. Register a web page, RSS feed or JSON endpoint, narrow it to the part you care about, and we poll it for you. When it changes, your webhook receives the event with an excerpt of the new content.

  • CSS selectors for pages, JSONPath for APIs
  • Fire on any change, a regex match, or a JSONPath comparison
  • Respects robots.txt and identifies itself with its own user agent

Polls of status.vendor.com Every 15 minutes

05:00
06:00
07:00
08:00
08:30 changed
09:00

$.status.indicator "none" "degraded"

Show the call
watch_create
watch_create({
  "source_type": "json_endpoint",
  "url": "https://status.vendor.com/api/v2/status.json",
  "jsonpath": "$.status.indicator",
  "match_rule": { "kind": "any" },
  "webhook_url": "https://api.yourapp.com/hooks/vendor-status",
  "poll_interval": "PT15M"
})

Plugs into the stack you already have

Agents that speak MCP connect to our hosted server and see every tool with a typed schema. Everything else, from LangChain to a shell script, uses the same operations over REST. Both reach the same data, so a deadline recorded over MCP shows up in the next REST query.

MCP

Add the server URL to your MCP client and authorize it with OAuth. Every tool has a strict JSON schema, which keeps malformed calls to a minimum.

schedule_create · schedule_cancel · schedule_list · schedule_get · deadline_remember · deadline_query · deadline_complete · deadline_snooze · approval_request · approval_status · approval_cancel · watch_create · watch_pause · watch_history …

MCP setup guide →

REST

A versioned /v1/ API with API-key auth and a published OpenAPI spec. Call it from any language, or generate a client from the spec.

Browse the OpenAPI spec →

Your webhook handler only has to check a signature.

Signed the same way as Stripe
HMAC-SHA256 over a timestamp and the body, so you can reject forged or replayed requests. When you rotate the secret, the old one keeps working for 24 hours.
Retried for up to 32 hours
Six attempts with backoff on 5xx responses and timeouts. A 4xx is treated as final. Anything that still fails goes to a dead-letter queue.
Recorded in the audit log
Every tool call, delivery and approval decision goes into an append-only log that you can export as CSV.
incoming webhook
POST /hooks/agent HTTP/1.1
X-AIGears-Signature: t=1781686800,v1=5257a86...
Content-Type: application/json

{
  "event_type": "schedule.fired",
  "event_id": "01JXK9B2…",
  "team_id": 42,
  "occurred_at": "2026-06-17T09:00:00Z",
  "data": { "schedule_id": "01JXK3M8…", "payload": { … } }
}

Know what your agents did, and when

When something goes wrong, the first question is what the agent actually did. The dashboard answers it. It shows an activity feed, upcoming callbacks and deadlines, pending approvals, active watches, API keys, and an audit log you can filter and export.

Activity
Time Event Detail Result
09:00:01 schedule.fired 01JXK3M8… → /hooks/agent 200
08:42:17 approval.approved 01JXK2F7… by [email protected] approved
08:30:55 watch.changed status.vendor.com: indicator is now "degraded" fired
07:15:09 deadline.escalation_fired ACME contract, 7 days out email sent

Pay for what we keep running for you

We don't bill per API call. Plans are sized by the state we hold and the sources we poll on your behalf. The free tier includes 3 active scheduled callbacks (a recurring one can fire every 15 minutes), 5 active deadlines, 1 active watch and 10 approvals a month. That's enough to run a real agent before you commit to anything.

Start free See full pricing →
Active callbacks
3
Approvals a month
10
Active deadlines
5
Active watch
1

Connect your first agent this afternoon.

Create a free account, then add the MCP server to your agent or create an API key for REST. The getting-started guide takes you from sign-up to your first webhook.

Start free Getting-started guide