Govern AI access with Adam
Adam lets people and agents use models, databases, APIs, and tools through Eve. Same permissions. Same approvals. Same audit trail.
Govern AI access with Adam
Adam lets AI use real systems through Eve. Same auth. Same policy. Same telemetry. Same cost controls.
AI access layer
Adam turns a request into approved tool calls, then sends every action through Eve for governed access.
Model Routing
OpenAI, Anthropic, Ollama, and OpenRouter through one policy-aware API.
RBAC-Scoped Access
AI uses the same permissions as the user. No side-door access.
Live Controls
Rate limits, budgets, PII rules, and audit trails run before the request executes.
Govern AI access with Adam.
Adam sends model and data access through Eve, so every action keeps the same auth, policy, telemetry, and cost controls.
Multi-Provider Models
Use OpenAI, Anthropic, Ollama, and OpenRouter through one interface.
- OpenAI, Anthropic, Ollama, OpenRouter
- Streaming & tool calling on all providers
- Custom base URL support for self-hosted models
Database Access
Connect databases as governed endpoints with pooling built in.
- Native wire protocols , RESP, PostgreSQL, MySQL, MongoDB, ClickHouse, Oracle
- Connection pooling with per-endpoint managers
- PSYNC and AOF replication support for Redis
Shared Auth & RBAC
One identity system for AI and data access.
- No privilege escalation
- Organization-scoped credentials
- Permissions checked on every request
Templates & Skills
Load prompts and skills at runtime without redeploying.
- Versioned prompts
- Runtime-loadable skills
- Swap templates mid-conversation
Credential Management
Keep credentials out of app code. Use TLS and rotation by default.
- Credentials isolated from application code
- TLS everywhere by default
- Automatic rotation support
Policy Enforcement
Observe, warn, or block risky commands before they run.
- Block dangerous managed-service commands
- Audit logs by service and command
- Connection context for compliance
One API for Models and Agents
Adam uses the same marketplace-backed endpoints as Eve, so model providers and agent clients share one governed access path.
Model providers
LLM endpoints Adam can route through Eve.
OpenAI
Default modelGPT-4, GPT-3.5, and other models from OpenAI for chat, completion, and embeddings.
gpt-4o
Anthropic
Default modelClaude models for safe, helpful AI assistants with large context windows.
claude-sonnet-4-6
Ollama
Default modelRun open-source LLMs locally. Supports Llama, Mistral, CodeLlama, and more.
llama3
OpenRouter
Default modelUnified API gateway for accessing hundreds of AI models from multiple providers.
meta-llama/llama-3-70b-instruct
Azure OpenAI (classic deployments)
Default modelMicrosoft Azure OpenAI service via the per-deployment URL ({endpoint}/openai/deployments/{deployment}/chat/completions?api-version=…). Auth via api-key header; deployment in the path selects the model.
gpt-4o
Agent clients
Agent workflows that can use Eden as the governed model path.
Hermes Agent
Default routeOpen-source, self-improving local agent from Nous Research.
openai/gpt-4o-mini
OpenClaw
Default routeOpen-source AI agent that connects to messaging and workflow surfaces.
openai/gpt-4o-mini
Kilo Code
Default routeOpen-source coding agent that works across editor and terminal workflows.
openai/gpt-4o-mini
Claude Code
Default routeAnthropic's agentic coding tool for terminal-based software work.
anthropic/claude-sonnet-4
Cursor
Default routeAI code editor with configurable model provider settings.
openai/gpt-4o-mini
Open WebUI
Default routeSelf-hosted LLM frontend and agent platform with OpenAI-compatible providers.
openai/gpt-4o-mini
Pieces
Default routePrivate, on-device memory layer for developer workflows.
openai/gpt-4o-mini
Descript
Default routeAI video and podcast editing workflow with agent-style automation surfaces.
openai/gpt-4o-mini
Roo Code
Default routeAutonomous coding agent for editor-based development workflows.
openai/gpt-4o-mini
Cline
Default routeAutonomous coding agent that can use custom model providers.
openai/gpt-4o-mini
Codex
Default routeOpenAI coding agent workflow for software engineering tasks.
openai/gpt-4o-mini
Let agents work through Adam.
Adam sits between users, agents, and internal systems. Eve checks access and records the action.
How Tool Calling Works
User sends chat request with database endpoint references
Adam connects to each endpoint's ATI server and discovers tools
Tool definitions sent to LLM alongside the conversation
LLM decides whether to call tools based on context
Adam verifies RBAC: does this user have access?
Tool result fed back into conversation (max 12 iterations)
Same permissions as the user. Always.
RBAC-Scoped AI Access
AI uses the same permissions as the user. No privilege escalation.
- Read-only if user is read-only
- Invisible endpoints stay invisible
- Same identity system for AI and data
Natural Language Queries
Ask questions in plain English. Adam queries through Eve with your permissions.
- No SQL required
- Context-aware responses
- Multi-database support
Tool Orchestration
Adam finds the right tools, calls them, and brings results back into the conversation.
- Tenant-isolated tools
- Cached tool discovery
- Managed and user-registered tools
Tool Execution Metrics
Track attempts, failures, and latency for every tool call.
- Attempt & failure counters
- Latency histograms
- Per-tool observability
Conversation Persistence
Keep long-running analysis or use ephemeral chats for one-off work.
- Persistent and ephemeral conversation modes
- SSE streaming with heartbeat keep-alive
- Resume conversations across sessions
Token Accounting
Track token use by conversation, user, organization, and provider.
- Per-conversation token tracking
- Prompt and completion breakdowns
- Organization-level usage aggregation
Turn AI telemetry into action.
Adam and Eve collect the signals needed to route better, block risk, and cut waste.
Anti-Pattern Detection
Adam flags performance issues in live traffic.
- N+1 query detection
- Hot key concentration via Space-Saving sketch (64-entry, O(1) lookup)
- Unbounded range warnings
PII Exposure Alerts
Detect and redact sensitive data before it is stored.
- SSN & credit card detection
- API key & password scanning
- Email, phone, IP detection
Recommendations
Turn traffic patterns into clear fixes, severity, and savings estimates.
- Pattern and context rules
- Confidence-scored output
- Cost savings estimates
Live Analytics
Watch endpoint health, latency, errors, and throughput in real time.
- Zero-overhead when unused
- Anomaly-only filtering
- 64-event broadcast buffer
Anomaly Detection
Detect traffic shifts, latency spikes, and error-rate changes.
- 3-window confirmation before alerting
- 5-window cooldown before reset
- Confirmation memory with 5-minute bridging windows
Adaptive Metadata Polling
Collect more metadata when traffic looks unusual.
- Normal → Watch → Elevated → Critical escalation
- Hysteresis prevents flapping between states
- ClickHouse storage with SummingMergeTree rollups
Detected Anti-Patterns
Flagged with confidence scores and recommended fixes.
N+1 Queries
5 repeated commands
Hot Keys
> 15% traffic
KEYS Command
Any occurrence
Unbounded Range
Any occurrence
Large Responses
> 64 KB
High Fanout
100+ keys in MGET/MSET
High Error Rate
> 10% rate
Missing TTLs
> 80% no TTL
Slow Queries
> 10ms
Dangerous Commands
FLUSHDB, SHUTDOWN, CONFIG
Large Hash Ops
> 5 KB per operation
Write-Heavy Never-Read
0 reads on pattern
Leave terminal. Open browser. Copy-paste. Lose your thought.
Adam lives in your terminal. Query databases, load skills — without switching.
Features
- Multi-provider support: Anthropic, OpenAI, Ollama, OpenRouter
- Auto-endpoint discovery from your Adam deployment
- Database querying via ATI with the same RBAC as your user account
- Real-time SSE streaming with heartbeat keep-alive and token-by-token rendering
- Conversation persistence: persistent mode for long-running analysis, ephemeral for one-off queries
- Skill system: toggle domain expertise on/off at runtime
- Tool approval gates for safe AI execution with server-side polling
- Model override: switch providers and models mid-conversation
Built-in Tools
eden_curl
Make authenticated API calls to Eden service from within AI conversation
load_skill
Dynamically load and enable a skill at runtime
show_form
Display interactive forms dynamically within the terminal
Sign in to try Eden Chat directly in your browser, connected to your real data with your real permissions.
Under the Hood
Framework
Built on ratatui, a real terminal application, not a web wrapper
Architecture
Elm Architecture (TEA) for predictable state management
Screens
Login → LLM Provider Select → Chat, full UX flow
Tool Execution
Server-side execution with polling, up to 12 tool passes per turn
Build agents without opening a side door.
Adam keeps agent access governed through Eve.