Skip to content
Now built for larger agent products

General Augment is the agent backend for your app

AI agents for every product surface.

General Augment gives existing apps the managed agent layer: Responses-compatible API, user memory, governed tools, approvals, channels, local connectors, usage, and traces. Your product keeps the UX, auth, billing, and source of truth.

Start buildingRead the docs
Project runtime
healthy
Tenant project
Surfaces
app, WhatsApp, SMS, Telegram, iMessage
Memory
profile, facts, search, delete
Connectors
Mac, VM, sandbox, private API
Usage
turns, tokens, tools, channels
Managed turn path
01
App backend calls /v1/responses
02
Memory and identity resolve
03
Allowed tools and connectors load
04
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
Tenant-owned capacity
Macs, VMs, sandboxes, provider keys
Why GA

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
Platform capabilities

Everything around the model turn.

Start with one backend call. Expand into memory, tools, channels, approvals, local capability hosts, and tenant-owned 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 tenant-owned Macs, VMs, coding sandboxes, private APIs, desktop automation, or provider adapters. The connector executes privately while GA governs policy, approvals, redaction, and audit.

Governed tool execution

Expose only allowed tool schemas to the runtime. 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 support evidence for every tenant.

Secure multi-tenant platform

Project keys stay server-side. Credentials, memory, traces, tools, and audit rows are encrypted, governed, and scoped per tenant 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 tenants.

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
Search
relevant context
Use
every surface
Use cases

Use cases now span apps, channels, local machines, private networks, and sandboxes.

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.

memorybriefingschannels
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.

approvalsauditidentity
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.

policybillingrisk
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.

OpenAPItoolstraces
View vertical page
Operations teams

Agents for private systems

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

private networkVMslocal
View vertical page
Developer platforms

Coding agents with governed sandboxes

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

sandboxauditBYO
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.

mobileprofilememory
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.

multi-tenantCLIdocs
View vertical page
Diagram showing how an existing app launches a WhatsApp assistant with General Augment
One project, every surface

Your product owns the relationship. GA 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
Telegram
Local iMessage
Backend jobs
Private tools
BYO connector model

Keep private execution where it belongs.

Some capabilities should run on a tenant machine, private network, or customer-owned provider account. A local connector owns execution. General Augment owns the policy, approvals, audit, redaction, and tool surface.

Local Mac
Tenant ownsiMessage, desktop automation, local app data
GA exposesOpaque refs, approval-required sends
Private VM
Tenant ownsProcess manager, private files, internal services
GA exposesHealth, approved actions, redacted results
Coding sandbox
Tenant ownsRepo checkout, package cache, test runner
GA exposesBounded code and test tools
Private network
Tenant ownsVPC/VPN-only APIs and internal tools
GA exposesNarrow actions without leaking hosts
Provider adapter
Tenant ownsTenant API keys, quota, spend controls
GA exposesSafe capability tools and usage evidence
The first packaged path is `npx @general-augment/local-imessage setup --project your-project --write-prompt --write-config`, which helps a tenant connect a Mac-backed iMessage adapter without exposing Apple IDs, phone numbers, local paths, transcripts, or provider tokens.
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 tenancy, 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.

Tenant 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
$0
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
Request Build access
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
Request Pro access
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
contact us
  • SLA & security review
  • Data residency controls
  • Optional dedicated deployment
  • Custom onboarding
  • Design partner access
Talk to us

SMS/WhatsApp delivery, complex model usage, and tenant-owned 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 freeTalk to the team