Account-aware assistant
The app backend sends account context and a user id to General Augment; the assistant answers with memory and allowed account tools.
Category comparison
Raw LLM APIs vs an agent backend
Raw LLM APIs are the right fit when a team wants direct model access and can build the surrounding product infrastructure. General Augment is the fit when an existing app needs an agent backend around those turns: server-side keys, stable users, memory, governed tools, approvals, channels, usage, and traces.
Use raw LLM APIs when
- You need direct control over model calls.
- The experience is a prototype, offline task, or narrow generation workflow.
- Your team already owns identity, tools, approvals, usage, and observability.
Use General Augment when
- The agent lives inside an existing product.
- Your app needs stable user identity, durable memory, governed tools, and audit trails.
- Browser and mobile clients should call your backend while project keys stay server-side.
Decision table
Compare the layer, not just the feature list.
Decision area
raw LLM APIs
General Augment
Model access
Raw APIs give direct control over prompts, models, parameters, and tool calls.
General Augment wraps model turns in an app-agent backend with memory, policy, approvals, usage, and traces.
User context
Your app must assemble user state, history, permissions, and retrieval for every call.
Send a stable app user id and let the project scope memory, trace, and channel identity to that person.
Production controls
Teams build their own approval gates, audit logs, cost tracking, and support views.
Those controls are first-class product surfaces behind the same `/v1/responses` route.
Architecture fit
Where the categories fit together.
Raw model APIs sit at the model layer. General Augment sits at the app-agent backend layer, between your product backend and the model/tool/channel systems the agent needs.
First backend call
curl https://api.generalaugment.com/v1/responses \
-H "Authorization: Bearer $GENAUG_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "balanced",
"user": "app-user-123",
"input": "Summarize this account and suggest the next action"
}'Migration path
Start where you are. Add the agent backend when the product needs it.
- 01Keep direct model calls for narrow generation tasks and prototypes.
- 02Move product-facing assistant turns behind the app backend.
- 03Call General Augment with the stable app user id, then add governed tools and memory.
- 04Store response ids and trace ids in app logs so support can inspect what happened.
Specific examples
Approval-gated action
The model can propose a refund, send, or account update, but General Augment holds execution until the app or operator approves it.
Usage evidence
Every turn records response ids, trace ids, token usage, tools, and channel activity for support and cost review.
When not to use General Augment
Use the smaller tool when the smaller tool is enough.
Use raw APIs when the feature is a simple generation endpoint with no durable user state.
Use raw APIs when your team intentionally wants to own the full agent infrastructure stack.
Use raw APIs when you need model-specific behavior that should not pass through an app-agent backend.
FAQ
Is General Augment a model API replacement?
No. Model APIs still matter. General Augment is the backend layer around product-agent turns when the app needs stable users, memory, governed tools, approvals, usage, and traces.
Can my app still choose models directly?
Yes. General Augment is designed for product teams that want the app-agent backend managed while keeping product logic, UX, auth, and source of truth in their own app.
When should I stay with raw LLM APIs?
Stay with raw APIs for prototypes, offline generation, narrow model calls, or teams that want to build their own memory, policy, observability, and approval stack.