Agents
Ready-to-Ship Agents
Oblien agents are fully managed - we handle all the infrastructure so you can ship immediately.
No backend setup. No user management. No storage configuration. Just ship.
What We Manage For You
- User Management - Authenticated users and guests, automatically tracked
- Session Management - Create, refresh, expire - all handled
- Guest Identification - Dual-layer (IP + fingerprint) tracking built-in
- Rate Limiting - Automatic limits for guests and users
- Token Generation - Secure JWT tokens created for you
- Storage - NodeCache built-in, Redis optional, no setup needed
- Authentication - API key/secret auth handled server-side
You focus on your product. We handle the agent infrastructure.
What's Included (Fully Managed)
Infrastructure (We Handle This)
- User tracking - Authenticated + guest users
- Session storage - NodeCache built-in, Redis optional
- Rate limiting - Automatic per-user/guest limits
- Token management - JWT generation, refresh, expiration
- Guest identification - IP + fingerprint dual-layer tracking
- Security - API keys server-side only, tokens for client
Agent Capabilities (You Configure These)
- Intelligent conversations - Context-aware, memory across sessions
- Tool execution - Database queries, API calls, file operations
- Context & knowledge - Upload docs, code repos, custom data
- Isolated workspaces - Secure sandboxed environments
- Activity tracking - Monitor all interactions and tool executions
Infrastructure is managed. You just configure agent behavior.
Use Cases
- Customer Support: Create agents that can answer questions, resolve issues, and escalate to human operators when needed
- Data Analysis: Build agents that can query databases, analyze data, and generate reports
- Content Generation: Deploy agents that can write articles, generate code, or create marketing copy
- Automation: Automate repetitive tasks by giving agents the tools to interact with your systems
- Interactive Applications: Embed intelligent assistants directly into your web applications
Architecture
┌─────────────────────────────────────────────────────────────┐
│ Your Application │
│ ┌────────────────┐ ┌─────────────────────────┐ │
│ │ react-chat- │ ◄──────►│ Agent Manager API │ │
│ │ agent │ │ (oblien SDK) │ │
│ └────────────────┘ └─────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Oblien Platform │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Agent │ │ Tools │ │ Context │ │Workspace │ │
│ │ Engine │ │ Manager │ │ Manager │ │ Manager │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────────┘Getting Started
Creating Your First Agent
Create and configure agents via dashboard or API
Integration Guide
Complete backend + frontend integration example
Agent Instructions
Configure behavior with custom prompts
Tools & Actions
Enable agent capabilities and tool execution
Why Oblien Agents Are Different
Traditional Approach (What You DON'T Have To Do)
// ❌ Build user management system
app.post('/signup', async (req, res) => {
const user = await db.users.create(...);
await sendVerificationEmail(user);
// ...hundreds of lines of auth code
});
// ❌ Build session storage
const sessions = new Map();
setInterval(() => cleanupExpiredSessions(), 3600000);
// ❌ Implement rate limiting
const rateLimiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 100 });
// ❌ Manage guest tracking
const guests = new Map();
// ...guest identification logic
// ❌ Generate and validate tokens
const token = jwt.sign({ userId }, secret, { expiresIn: '1h' });
// ❌ Set up Redis/database
const redis = new Redis({ host, port, password });That's hundreds of lines of infrastructure code you DON'T need.
Oblien Approach (What You Actually Do)
// ✅ Two lines - that's it
const chat = new OblienChat(client);
const session = await chat.createSession({ agentId, namespace: userId });
// Done. User management, sessions, tokens - all handled.We manage everything. You ship your product.
How It Works
Backend: One Function Call
import { OblienClient, OblienChat } from 'oblien';
const client = new OblienClient({
clientId: process.env.OBLIEN_CLIENT_ID,
clientSecret: process.env.OBLIEN_CLIENT_SECRET
});
const chat = new OblienChat(client);
// For authenticated users - we track them automatically
const session = await chat.createSession({
agentId: 'your-agent-id',
namespace: req.user.id // We handle the rest
});
// For guests - we identify and track automatically (IP + fingerprint)
const guestSession = await chat.createGuestSession({
ip: req.ip,
fingerprint: req.body.fingerprint, // We handle dual-layer tracking
agentId: 'your-agent-id' // Rate limiting built-in
});
// Returns token to frontend
res.json({ token: session.token });That's it. Sessions, users, guests, rate limits - all managed.
→ Core SDK docs - Backend session creation
Frontend: Drop-In Component
import { ChatProvider, ChatPanel } from 'react-chat-agent';
<ChatProvider authConfig={{ sessionId, accessToken }}>
<ChatPanel />
</ChatProvider>Chat UI ready. Agent connected. Done.
→ Chat SDK docs - Frontend integration
→ Complete integration guide - Full example
Next Steps
Creating Agents
- Create an Agent - Via dashboard or API
- Configure Instructions - Define behavior
- Add Tools - Enable capabilities
- Set Context - Provide knowledge
Integrating Agents
- Integration Guide - Complete backend + frontend flow
- Core SDK - Backend session management (Node.js)
- Chat SDK - Frontend interface (React)