The agent backend for every product surface.

Add a production agent to your app with memory, governed tools, approvals, channels, usage, and traces. Your product keeps the UX, auth, billing, and source of truth.

Start building Read the docs

Project backend

Your project

Surfaces

app, WhatsApp, SMS, Telegram, iMessage

Memory

profile, facts, search, delete

Connectors

Mac, VM, sandbox, private API

Usage

turns, tokens, tools, channels

Agent backend flow

App backend calls /v1/responses

Memory and identity resolve

Allowed tools and connectors load

Trace, usage, audit, and reply return

model: balanced
user: app-user-123
trace: ga_trace_...

One backend call

Responses-compatible API

One user id

Memory, traces, approvals

One policy layer

Tools, channels, connectors

Private capacity

Macs, VMs, sandboxes, provider keys

Why General Augment

Calling an LLM is the easy part.

The hard part is making an agent safe, useful, observable, and connected to real users and real product systems. General Augment gives you that backend.

user identity

durable memory

tool policy

approval gates

message delivery

delivery retries

cost controls

audit logs

credential vault

local connectors

private network access

provider capacity

Compare your options

Already evaluating agent SDKs, frameworks, or infrastructure?

View all comparisons

raw LLM APIs

LLM API vs Agent Backend

The agent lives inside an existing product.

Compare

agent frameworks

Agent Framework vs Managed Agent Backend

You want an app-agent backend instead of a custom platform project.

Compare

Vercel AI SDK

Vercel AI SDK vs Agent Backend

You need a managed backend that existing app backends can call.

Compare

Cloudflare Agents

Cloudflare Agents vs Agent Backend

Your app needs a managed agent backend above runtime primitives.

Compare

Platform capabilities

Everything around the model turn.

Start with one backend call. Expand into memory, tools, channels, approvals, local capability hosts, and your provider capacity.

Agent chat for existing apps

Add a secure assistant behind your own product UI while your app keeps auth, billing, user accounts, and source of truth. The same project can power in-app chat, backend jobs, and external channels.

User memory that follows the person

Store durable facts, preferences, and summaries against your stable app user id, then retrieve, inspect, delete, or purge them through server-side APIs.

Bring your own connectors

Attach your own Macs, VMs, coding sandboxes, private APIs, desktop automation, or provider adapters. The connector executes privately while General Augment governs policy, approvals, redaction, and audit.

Governed tool execution

Expose only allowed tool schemas to the agent. Validate inputs, rate-limit calls, redact payloads, and require approval for sensitive writes such as outbound message sends.

Observability and usage

Capture response ids, trace ids, token usage, tool calls, memory events, logs, channel status, and usage details for every run.

Secure project isolation

Project keys stay server-side. Credentials, memory, traces, tools, and audit rows are encrypted, governed, and scoped per project and app user.

User memory

The agent remembers the user, not just the thread.

Send the same stable app user id to `POST /v1/responses`, memory store, search, profile, delete, and purge. General Augment keeps memory scoped to the project and user so future turns can recover useful context without leaking across projects.

See the user flow

User memory profile

app-user-123

Preferences

Seat choices, communication style, dietary notes, favorite workflows

Work context

Current projects, recurring meetings, open tasks, previous summaries

Care context

Care plan reminders, escalation notes, consent-aware follow-up

Support context

Account history, unresolved issues, prior tool outcomes, sentiment

Store

durable facts

relevant context

Use

every surface

Use cases

Use cases across apps, channels, private systems, and product workflows.

Personal productivity

A daily agent that remembers context

Morning briefings, meeting prep, reminders, inbox triage, and proactive follow-up across in-app chat, Telegram, SMS, or a local Mac connector.

Example workflow: Daily briefings from product data and durable user memory

View vertical page

Health and care

Guided support with guardrails

Care navigation, intake summaries, follow-up tasks, escalation, and patient messaging with approval gates and auditable tool calls.

Example workflow: Intake summaries and care navigation from trusted app context

View vertical page

Fintech and marketplaces

Policy-aware account actions

Support agents, dispute workflows, onboarding help, payment follow-up, and risky operations that require explicit approval before execution.

Example workflow: Dispute triage and payment follow-up with traceable outcomes

View vertical page

Vertical SaaS

A product expert inside the app

User onboarding, report generation, product Q&A, workflow automation, and API-backed actions without shipping a custom agent platform.

Example workflow: Product Q&A grounded in account context and app permissions

View vertical page

Operations teams

Agents for private systems

Connect internal APIs, private network tools, local files, and workflow hosts while keeping execution in customer-owned infrastructure.

Example workflow: Internal service lookups through a private network connector

View vertical page

Developer platforms

Coding agents with governed sandboxes

Expose bounded repo, build, test, and deploy actions from a customer-owned sandbox while General Augment handles the agent policy layer.

Example workflow: Repo-aware assistants that can propose, test, or verify changes

View vertical page

Consumer apps

Native assistants that feel personal

Persistent preferences, reminders, customer support, profile updates, and account actions that follow users across app and messaging surfaces.

Example workflow: Personalized support and profile updates from the app backend

View vertical page

Agencies and studios

Repeatable client agent launches

Use the same project, key, memory, tools, and connector pattern across many client apps without rebuilding the platform each time.

Example workflow: Project-per-client setup with scoped API keys and usage evidence

View vertical page

One project

every surface

Product surfaces

Product chat

same app user

WhatsApp and SMS

linked channels

Backend jobs

durable runs

Private tools

approved actions

General Augment governs

Shared agent layer

One identity, one memory plane, one policy surface.

Memory

Policy

Approvals

Traces

app user to project policy to tool or channel to audited reply

One project, every surface

Your product owns the relationship. General Augment powers the agent layer.

Use one project for product chat, WhatsApp, SMS, Telegram, backend jobs, local iMessage, and future surfaces. The same user identity, memory, tools, policies, traces, and usage evidence follow the experience.

In-app chat

WhatsApp and SMS

Local iMessage

Backend jobs

Private tools

BYO connector model

Keep private execution where it belongs.

Some capabilities should run on your machine, private network, or provider account. Your connector owns execution. General Augment owns the policy, approvals, audit, redaction, and tool surface.

Where it runs

You keep

You get

Local Mac

You keepiMessage, desktop automation, local app data

You getOpaque refs, approval-required sends

Private VM

You keepProcess manager, private files, internal services

You getHealth, approved actions, redacted results

Coding sandbox

You keepRepo checkout, package cache, test runner

You getBounded code and test tools

Private network

You keepVPC/VPN-only APIs and internal tools

You getNarrow actions without leaking hosts

Provider adapter

You keepYour API keys, quotas, spend controls

You getSafe capability tools and usage evidence

Connect local iMessage

Use this when your product agent needs to read, search, or send iMessages from a Mac you control. Run the setup command on that Mac:

npx @general-augment/local-imessage setup --project your-project --write-prompt --write-config

General Augment gets approved read, search, and send tools. Apple IDs, phone numbers, local paths, transcripts, and provider tokens stay out of prompts and committed files.

Developer API

Works like an API your backend can adopt incrementally.

Keep project keys server-side. Use `simple`, `balanced`, or `complex` tier routing. Add explicit user memory, OpenAPI tools, local connectors, and verification once the first response is working.

POST /v1/responses

curl

curl https://api.generalaugment.com/v1/responses \
  -H "Authorization: Bearer $GENAUG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Idempotency-Key: morning-briefing-1" \
  -d '{
    "model": "balanced",
    "user": "app-user-123",
    "input": "Build a morning briefing from memory and tools",
    "metadata": {"feature": "briefing"}
  }'

response id

trace id

usage

Security and governance

Built for agents that take action.

General Augment treats tools, memory, credentials, channels, and connector execution as production systems. The platform is designed around project isolation, approval, audit, observability, and budget evidence from the start.

Project-scoped API keys

Keys stay in trusted backend code and can be separated by production, staging, development, and CI.

Project and user boundaries

Memory, credentials, traces, audit rows, and tool policy are isolated by project and app user.

Approvals before side effects

Sensitive writes, sends, and private actions can wait for approval before the connector or tool executes.

Usage and budget controls

Track tokens, turns, memory operations, channel events, and cost evidence before billing or scaling traffic.

Pricing

Usage-based plans for agent turns, tools, memory, and channels.

Free

per month

1 app
100 monthly active users
3,000 agent turns / mo
$2.50 promotional usage credit
5 tools
7-day logs

Start free

Build

$20

per month

2 apps
500 monthly active users
10,000 agent turns / mo
$25 usage credits / billing period
10 tools
Email support

Start Build

Pro

$79

per month

5 apps
5,000 monthly active users
50,000 agent turns / mo
$100 usage credits / billing period
50 tools
Priority email support

Start Pro

Team

$249

per month

10 apps
10,000 monthly active users
100,000 agent turns / mo
$350 usage credits / billing period
100 tools
Custom & private MCP tools
Priority email support

Request Team access

Enterprise

Custom

Custom usage limits
Security review path
Private connector planning
Advanced onboarding
Dedicated support options

Contact sales

SMS/WhatsApp delivery, complex model usage, and your provider capacity may be billed separately.

Your product should not build its own agent platform.

Start with one backend call. Add memory, governed tools, channels, local connectors, observability, and billing controls as your agent surface grows.

Start building Read the docs