01
Your end clients build
They expand your platform with their own ideas and requirements, in plain English or their own language.
What is Kareenos
An engine that sees, knows where, and speaks every channel.
Kareenos is your on-premises agentic operations platform. Not a chatbot, not a copilot. An agentic engine that runs your operations, shipped as Docker images on your infrastructure.
Node.js · PostgreSQL · Cassandra · Docker · Anthropic / OpenAI / Gemini / DeepSeek
The big picture
Between your platform
and everyone it serves.
Your end-clients' teams and customers live on Kareenos surfaces: web app, mobile app, messaging, voice. The engine reasons in the middle. Your platform's databases and APIs stay the source of truth.
Clients of your end‑clients
Your end-clients
Kareenos Web App
Kareenos Mobile App
Kareenos MessagingWhatsApp · Telegram · Email · SMS
Kareenos VoicePhone calls · realtime voice
KareenosAgentic Engine
Your PlatformYour DBs · your APIs
Inside the engine
Two layers. Authoring builds, runtime runs.
The authoring layer produces and versions artifacts: one Super Agent, guided by system rules and memory. The runtime layer executes live workflows. Everything below on this page is one of these blocks, shipped.
Authoring layer
produces and versions artifacts
Super AgentSystem RulesMemoryRuntime layer
executes live workflows
Intent BusIntent DispatcherK-AgentsK-JobsLive WorkbooksData AdaptorsToolsMessaging EngineStorage
Who it's designed for
Three audiences. One engine.
02
Business users run it
No code, no training. They describe what they need, and it runs.
03
Your tech team ships once
They design new features once, then ship them to every client through the Kareenos marketplace.
What people build
Anywhere people and assets move,
and operations need to run themselves.
field operations
Dispatch to proof of delivery
Job assignment, shift compliance, proof of delivery. A vehicle stops too long, an agent investigates and briefs the supervisor.
customer communication
Every channel, answered
Agents that answer WhatsApp, take phone calls, chase unpaid invoices, confirm appointments, and follow up when nobody replies.
fleet & assets
GPS events become actions
Unauthorized zone entry triggers verification, evidence compilation, and notification, automatically.
security & guards
Escalations that run themselves
Patrol verification, incident reporting with photo evidence, escalation chains that run themselves.
home care & workforce
Coordination without chasing
Visit confirmations, missed check-in escalations, schedule changes communicated across staff and families.
back office
Records that assemble themselves
Live sheets that update themselves, reports that write themselves, records that are audit-ready without anyone assembling them.
Why Kareenos for my business
Nobody builds their own database engine.
Nobody should build their own agentic engine.
01
The database lesson
Every platform since the 90s needed a database engine. Nobody built their own.
02
The 2026 equivalent
Every vertical platform from 2026 needs an agentic engine. Nobody should build their own.
03
A partner, not a project
A partner improves your engine daily. Your platform stays ahead without hiring an AI team.
04
A revenue line, not a cost
Every token your clients consume is money for you, on top of your subscription.
05
Sell intelligence
Stop selling tracking. Start selling intelligence.
06
Today, not tomorrow
The agentic era is here. Sell tokens today, not tomorrow.
Ownership
It's your brand. Always.
- Nobody's database engine is part of their brand. Neither is your agentic engine.
- Kareenos runs on-prem. Your data and your clients' data never leave your space.
- Start under the Kareenos brand. Graduate to your own name on everything, when you're ready.
- Either way: your servers, your brand, your business.
The team app
MyKareenos: people and agents, working together in real time
A simple web and mobile app for your end-clients’ teams. Agents generate tasks and follow up; people respond by chat, voice, or one tap. Tasks arrive with proof built in: photos, scans, signatures, and live location when the job needs them.
- One inbox for everything agents send: tasks, alerts, requests, reports
- Respond by chat, realtime voice, or a single tap
- Proof of work: photos, QR scans, signatures, live location
- Your partner brand on every screen, web and mobile
myKareenos mobile · tasks, chat, realtime voice
The container
Projects: everything lives inside one
Agents, documents, channels, connections, jobs: everything lives inside a project, and everything inside works together. Nothing ever crosses between projects. A project is the agentic company: one operational umbrella, one hard isolation boundary.
- Agents, sheets, jobs, documents, and channels under one umbrella
- Isolation enforced by the runtime: nothing crosses between projects
- The project description doubles as the operating manual
- Bootstrap a whole project from one prompt, or assemble it manually
The map
Workflow: the result, not the starting point
Every project has a live workflow view. This is what your client’s plain language becomes: nobody drew the diagram. The client described what they needed, and the engine built the agents, jobs, sheets, and connections behind it. And it stays editable, directly, anytime.
- Rebuilt from what actually exists, never hand-maintained
- Agents, jobs, sheets, intents, zones, actions, widgets, documents as nodes
- Drag a wire and the builder does the wiring work
- Your client or your team can open it and change the system
The architect
Super Agent: one agent builds everything
Your client talks to the Super Agent in plain language, and it designs the project: agents, jobs, sheets, workflows, connections. It is the architect, not a worker. It never sits in the operations flow. It builds the company, then the company runs itself.
- Natural language in, working agents and workflows out
- Maps your database schema and generates connectors automatically
- Reusable skills library grows with every deployment
- Authoring only: it never talks to your end customers
The workforce
K-Agents: the employees of the agentic company
Each K-Agent has a role, a focused job, and the tools to do it. They listen to events, reason about what to do, talk to teams and customers across every channel, and hand deterministic work to jobs. Built by the Super Agent, working for the business.
- Triggered by intents, chat, schedules, or other agents
- Bounded tools per agent, so a minimal permission surface
- Entry agents discover and dispatch skill agents at runtime
- Two-tier memory: per-conversation session + cross-conversation long-term
The data substrate
Live Workbooks: spreadsheets that are alive
Agents read them, write them, and react when a cell changes. A row updates and an agent notices; a number crosses a threshold and a workflow fires. Teams and agents work in the same sheets in real time, on three storage engines behind one tool surface.
- Workbook → sheet → column → row, collaborative in real time
- Postgres engine: formulas, geometry, cross-sheet lookups
- Cassandra engine: telematics-grade event volume
- If your client can use a spreadsheet, they can run an operation
The knowledge
K-Documents: knowledge in, documents out
In: your client’s library. Policies, manuals, price lists, contracts. Drop a file in, and every agent in the project knows it. Out: agents write documents too. Reports, briefings, and summaries in clean formats, audit-ready without anyone assembling them.
- Markdown, HTML, and text with auto-extracted searchable content
- Bilingual full-text search (English + Arabic)
- Per-document ownership and privacy
- Public share links with revocable tokens
The engine knows where
Location Runtime: Kareenos understands the physical world
Location, geofences, routes: the engine does not just see coordinates, it understands them. Route optimization across stops, traffic, and time windows; the right people in the right place at the right hours; all reasoned by agents, computed by jobs.
- Live tracking with a live map and historical playback
- Zones with dwell logic: checkin/checkout fire once per entry and exit
- Geocoding, reverse geocoding, and driving routes up to 23 waypoints
- OR-Tools route optimization in the Python tier: about 1–2s for 30 stops
The engine sees
Vision Runtime: Kareenos can see
A delivery photo, a camera frame, a damaged package, a site inspection shot. Agents do not just receive images: they understand them, verify them, and act on them. Proof of delivery confirmed. Unauthorized person flagged. Damage documented with evidence attached.
- Capture sessions: photo batches + voice note, from mobile or web
- Named vision channels: each finalized session fires a typed intent
- K-Jobs run YOLO26 object detection and InsightFace embeddings in the Python tier
- Multiple processors share one session payload: detections, transcript, verdicts
The humans
Teams: agents work beside your client’s people
Agents do not replace teams; they work beside them. Field staff, supervisors, dispatchers, managers, all inside MyKareenos. Agents assign tasks, follow up, and escalate. Humans confirm, respond, and decide. The agents run the routine; the humans make the calls.
- Business teams with per-module access levels
- Agents assign and chase; people confirm and decide
- Escalations reach a human the moment judgment is needed
- Invite by email; new members land in their team
For you, our software partner
We integrate with the best,
so you don't have to.
AI models, voice, speech, maps, search, payments, all connected under one umbrella. Your keys, your accounts, your control. Every integration below is live in the platform now, the same catalog your admins see in the API Keys console.
AI Models
Anthropic
Claude models with prompt caching. The platform default.
OpenAI
GPT models, Whisper STT, and vision fallback.
Google Gemini
Gemini models for reasoning and multimodal runs.
DeepSeek
Cost-efficient models for high-volume agent work.
Speech & Audio
Deepgram
Streaming speech-to-text tuned for phone audio, plus TTS.
ElevenLabs
Natural streaming text-to-speech for live calls.
Voice & Telephony
Voice Streaming (Twilio)
Real-time phone calls: callers talk to agents, agents transfer mid-call.
Messaging Channels
Two-way conversations, media, and voice notes.
Telegram
Bots and group coordination.
SMS
Reach anyone with a phone number.
Inbound triggers agents; outbound tracked.
Maps & Location
Google Maps
Geocoding, routing, distance, and GIS tools for agents.
Search
Google Search
Agents research the open web when the job needs it.
Account Linking
Google Workspace
Gmail, Calendar, Drive, and Sheets with per-user OAuth.
Microsoft 365
Outlook mail and calendar with per-user OAuth.
Your platform’s superpowers
Partner Tools: your systems become agent capabilities
Tools you build once, available to every agent, in every project, for every client. Your existing APIs, your core features, your secret sauce, exposed as tools agents can use. Every call is identity-mapped: it runs as that customer, never as a shared login.
- Partner-authored tools alongside the built-in catalog
- Granted per agent, with the same permission model as every other tool
- Per-account identity mapping resolves your system’s IDs at call time
- Tool calls observable as intents, like all platform activity
The revenue line
Billing: your accounting department, built in
A complete billing system. Track every client’s token consumption, your revenue, and your AI provider costs, all in one place. It even helps you design your pricing plans, fully integrated with Stripe. A turnkey solution: revenue from day one.
- Per-client consumption, credits, plans, and payments in one view
- Model price sheets kept in sync as providers change pricing
- Design plans against real cost economics
- Stripe subscriptions, checkout, and self-service portals built in
Full control
Control: your servers, your keys, your models, your rules
Choose your AI providers. Set every client’s limits. Grant every user’s access. Watch every token, every cost, every run, with live system configuration and continuous monitoring dashboards. Nothing hidden, nothing locked away. It’s your engine; you hold the keys.
- Runtime system configuration, editable live
- Per-client caps and per-user access grants
- Usage dashboards across accounts, endpoints, and time
- Your provider keys, your accounts, your data
No black box
Debugger, Plans, and Todos: see exactly what agents think and do
The Debugger shows every step: what the agent reasoned, which tools it called, what it cost. Plans show what an agent intends to do before it does it. Todos track what is done, what is pending, what is next. Full insight, full control, on every run.
- Step-by-step reasoning, tool calls, and cost per run
- Plans reviewable before execution
- Todos across every build and every run
- Per-run session recordings for later review
Under the hood
The machinery under all of it.
Everything above runs on the subsystems below. Every one is a shipped part of the engine, not a roadmap item.
The spine
Intent Bus: every event becomes a typed intent
The nervous system of the platform. Operational events become lightweight typed intents on an internal bus: a message arrives, a GPS ping crosses a geofence, a row changes, a schedule slips. Agents and jobs subscribe; nothing is hard-coupled.
- Agents never call agents directly. They publish intents
- New consumers subscribe without touching existing workflows
- Project-scoped fan-out: intents only reach same-project listeners
- Built on a distributed work queue, horizontally scalable
event
geofence_exit
hubIntent Bustyped intent · project-scoped
shieldAfter-hours Agentchecks schedule → calls driver
smsOwner Brief Agentlogs incident with context
table_chartWorkbook Jobwrites event row
Deterministic muscle
K-Jobs: sandboxed JavaScript where determinism matters
Not everything should be an LLM call. K-Jobs run deterministic JavaScript in a resource-limited sandbox, with five trigger types: scheduled, intent, data-change, agent call, and persistent. Agents handle judgment; jobs handle clockwork.
- Five triggers: cron, intent, workbook change, agent call, persistent
- Sandboxed with timeouts, call-depth limits, and explicit per-job grants
- Python tier via ctx.py.run: OR-Tools, numpy, pandas, scipy, networkx, torch
- Agents and jobs call each other across the same project, within budget caps
event
payment_overdue
AI Agent · reasons
tone: second reminder → schedule a call
Code Job · executes
Agents reason. Jobs execute.
Your database, activated
Data Adaptors: read your schema, never touch your data
Read-only connectors expose your existing Postgres, MySQL, MSSQL, Cassandra, Mongo, REST, or GraphQL systems as live sheets. The Super Agent reads your schema and generates them automatically. Write patterns are rejected by construction.
- Postgres, MySQL, MSSQL, Cassandra, Mongo, REST, GraphQL
- Generated automatically from your schema in minutes
- Sandboxed and read-only: writes are rejected, not just discouraged
- Your data never leaves your environment
cable
Read-only · Auto-generated · In place
Where people already are
Messaging Engine: WhatsApp, Telegram, SMS, email
Inbound messages become intents that wake agents; outbound messages are queued, tracked, and persisted with media. Field staff answer voice notes on WhatsApp; owners get email digests; customers get SMS updates. All of it lands in one conversation history.
- WhatsApp, Telegram, SMS, and email, two-way
- Media (photos, documents, voice notes) persisted to object storage
- Auto-reply pipeline lets cost-efficient models handle volume
- Every message indexed and auditable
smart_toyShift Coverage Agent online · actingmore_horiz
mic0:10“Can’t make my 6 a.m. shift, sorry…”
Got it, Sara, feel better. I’m contacting 3 qualified caregivers near the client now.
task_alt Shift covered · Maria T. confirmed · 5:52 a.m.
Real-time calls
Voice Channel: agents that answer the phone
A dedicated real-time audio loop: streaming speech-to-text in, agent reasoning, streaming text-to-speech out. Callers hear the first sentence while the rest is still generating; barge-in interrupts cleanly; agents transfer callers to other agents mid-call.
- Twilio media streams with streaming STT (Deepgram)
- Streaming TTS (ElevenLabs / Deepgram) with sentence-level latency
- Barge-in: callers can interrupt naturally
- Warm agent-to-agent transfer on the same call
phone_in_talkInbound · Reception Agentlive call · 02:34streaming
Caller “…can someone be there before noon?”
Agent “Yes, I’ve got a technician 14 minutes away. Booking him now, you’ll get an SMS confirmation.”
Attended automation
Browser Channel: agents acting in the user’s own browser
Agents navigate, read, fill, and click in a user’s signed-in browser session, with the user present and a server-held approval gate on sensitive actions. No credentials stored, no headless ghosts: attended automation with an audit trail.
- Navigate, read, click, fill, screenshot, scroll
- Server-held approval gate for clicks
- User’s own session, no stored credentials
- Per-project policy toggle
language
The user’s browser, supervised
Follow-through
Scheduled Callbacks: agents that remember to follow up
An agent can schedule its own future wake-up: “check this quote again Thursday,” “confirm the sub on Sunday evening.” Callbacks are persisted durably, claimed exactly once across replicas, and delivered at-least-once with retry.
- Agents register their own future wake-ups with payloads
- Durable queue that survives restarts and deploys
- Claim-once semantics across multiple workers
- Retry with exponential backoff on failure
alarm_on
Tuesday’s promise, kept Thursday
Continuity
Memory: context that survives the conversation
Two tiers: session memory scoped to a conversation, and long-term memory that persists across conversations with TTL. Long runs stay sharp through conversation compaction. Old slices are summarized once, preserving names, decisions, and outstanding work.
- Session + long-term tiers, append-only and auditable
- Compaction keeps multi-day runs within token budgets
- Names, decisions, and open items preserved through summaries
- Memory rules injected per agent via system rules
psychology
Session · Long-term · Compaction
Model-agnostic
Multi-model: Anthropic, OpenAI, Gemini, DeepSeek
One normalized model configuration, translated per provider at request time. Default to Claude with prompt caching; route high-volume work to cost-efficient models; a vision pre-processor closes the gap for text-only models. Upgrade-safe as the model market shifts.
- Provider-agnostic config: swap models without rebuilding agents
- Anthropic prompt caching: ~10× cheaper repeated context
- Vision pre-processor for text-only models
- Mix premium and budget models per agent, per task
auto_awesome
One schema · Every provider
Isolation by construction
Security: tenant isolation and encryption at rest
Nested tenancy (partner, account, project) with the project as a hard runtime boundary: intents fan out only to same-project listeners. Secrets and tokens are encrypted at rest, with master keys held in your own key management.
- Project isolation enforced by the runtime, not by convention
- Secrets encrypted at rest; master keys stay in your KMS
- Per-agent tool grants keep the capability surface minimal
- Approval gates on sensitive channels
shield
Partner → Account → Project
The backbone
PostgreSQL + Cassandra: scale without ceilings
Postgres holds the relational truth: agents, projects, workbooks, documents. Cassandra absorbs the volume of messages, memory, events, calls, and files, partitioned per tenant and replicated multi-DC. Stateless web and worker tiers scale horizontally.
- Postgres for authoring and relational state
- Cassandra for high-volume operational streams
- Multi-datacenter replication
- Stateless HTTP and worker processes: add nodes, not rewrites
storage
Relational truth · Unbounded volume
Yours to run
Deployment: Docker images in your infrastructure
Three core processes (web server, jobs engine, messaging engine) plus dedicated real-time servers for voice and browser channels. Pull the images into your VPC, on-prem cluster, or cloud account. Connect your database. Brand it. Thirty minutes.
- Ships as Docker images, deployed in your environment
- Your VPC, your cloud, your data center
- Stateless processes behind your load balancer
- Customer data never leaves your environment
deployed_code
Pull · Connect · Brand · Live
For your engineering team
See it running. Thirty minutes.
We'll deploy Kareenos against a sample of your schema before the call. You get the technical deployment spec, the architecture deep-dive, and a working environment to poke at.