Private Developer Preview

The Serverless Cloud for Long-Running AI Agents

Write pure TypeScript. We handle execution state, long-term memory, and asynchronous pauses. Build autonomous agents that run for weeks, not minutes.

Request Early AccessSee How It Works

What used to take an architecture now takes 15 lines

No databases. No queues. No webhook retry logic. Just TypeScript with built-in durability.

The Traditional Way7+ files · 5 services
// SDR follow-up agent: 7-day async outreach
// Infrastructure: Lambda + DynamoDB + SQS + EventBridge

const dynamoDB = new DynamoDBClient({});
const sqs = new SQSClient({});
const eb = new EventBridgeClient({});

export async function handler(event: APIGatewayEvent) {
  const lead = JSON.parse(event.body!);

  // Save state manually - you are the database now
  await dynamoDB.send(new PutItemCommand({
    TableName: 'agent-state',
    Item: {
      pk: { S: lead.id },
      status: { S: 'researching' },
      data: { S: JSON.stringify(lead) },
      ttl: { N: String(Date.now() / 1000 + 86400 * 30) },
    },
  }));

  // Queue the research step
  await sqs.send(new SendMessageCommand({
    QueueUrl: process.env.RESEARCH_QUEUE_URL!,
    MessageBody: JSON.stringify({ leadId: lead.id }),
  }));

  return { statusCode: 202 };
}

// research-worker.ts - separate Lambda, separate deploy
export async function researchWorker(event: SQSEvent) {
  for (const record of event.Records) {
    const { leadId } = JSON.parse(record.body);
    const state = await dynamoDB.send(new GetItemCommand(/*...*/));
    const research = await fetch(`https://api.apollo.io/...`);

    // Update state in DynamoDB
    await dynamoDB.send(new UpdateItemCommand(/*...*/));

    // Schedule wake-up in 7 days via EventBridge
    await eb.send(new PutRuleCommand({
      Name: `followup-${leadId}`,
      ScheduleExpression: 'rate(7 days)',
    }));
    await eb.send(new PutTargetsCommand({
      Rule: `followup-${leadId}`,
      Targets: [{ Arn: process.env.FOLLOWUP_LAMBDA_ARN! }],
    }));
  }
}

// followup-worker.ts - yet another Lambda...
// retry-handler.ts  - dead letter queue consumer...
// cdk-stack.ts      - 200 lines of IAM roles & permissions...
The Alveus Way1 file
// SDR follow-up agent: 7-day async outreach
// Infrastructure: none

import { agent$ } from '@alveus-ai/core';

export default agent$(async (state, input, ctx) => {
  // Research the lead - ctx.fetch is durable
  const research = await ctx.fetch(
    'https://api.apollo.io/v1/people/match',
    {
      method: 'POST',
      headers: {
        'x-api-key': ctx.secrets.get('APOLLO_API_KEY'),
      },
      body: JSON.stringify({ email: input.email }),
    },
  );

  // Have the LLM draft a personalized email
  const email = await ctx.llm.chat([
    { role: 'system', content: 'You are an elite SDR.' },
    { role: 'user', content: `Write a cold email
      using: ${await research.text()}` },
  ]);

  // Sleep for 7 days - survives deploys & restarts
  await ctx.sleep('7d');

  // Wake up and send the follow-up
  await ctx.fetch('https://api.sendgrid.com/v3/mail/send', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${ctx.secrets.get('SENDGRID_KEY')}`,
    },
    body: JSON.stringify({
      to: input.email,
      subject: 'Quick follow-up',
      html: email,
    }),
  });
});

Built for agents that never stop

Everything you need to deploy production AI agents.

Agents That Wait

Agents can safely pause for days - waiting for human approvals, API rate limits to reset, or a user to reply. They resume exactly where they left off, surviving deploys and restarts.

Serverless Agent Hosting

Forget provisioning databases or managing retry queues. Deploy multi-step agentic workflows with one command and let the engine handle the state.

Pure TypeScript

No YAML, no DSLs, no framework lock-in. Write agents in plain TypeScript with full type safety, Zod-validated tool schemas, and first-class LLM support.

Encrypted Secrets

API keys are encrypted at rest and injected at runtime. They never appear in logs, workflow history, or your codebase. Validated before every deploy.

Ready to build agents that run for weeks?

We're onboarding developers for our Private Developer Preview. Spots are limited.