Everything your
agents were missing.
One Docker container. Connects to any storage you already have. Gives every agent, every model, and every person on your team a governed, persistent, RAG-enabled API to collaborate on your real data — without moving a byte.
The six things that are
killing your agent deployments
These aren't edge cases. Every developer building agentic AI hits all six. Olympus was built specifically to eliminate them.
Every session starts cold
You build a capable agent. It does excellent work. You close the session — and it's gone. No memory, no context, no continuity. Tomorrow you start over. This makes agents unreliable for anything real.
Agents can't touch your actual files
You end up copy-pasting docs into prompts, writing brittle file-reading hacks, or just keeping agents away from real data entirely. There's no clean, governed path from an agent to a filesystem. So agents stay in the sandbox.
One API change and you start over
Every developer building on a single LLM knows this anxiety. OpenAI changes pricing. Anthropic deprecates a model. Your entire agent's memory, prompt architecture, and tool integrations are coupled to that vendor. There's no abstraction layer underneath you.
Multi-agent handoff is duct tape
Getting two agents to hand off work, share context, or build on each other's output requires custom orchestration code that's fragile and hard to debug. There's no shared workspace, so every team reinvents it — badly.
Compliance kills every interesting deployment
You build something genuinely useful, try to deploy it inside a real company, and immediately hit the wall. Security review. Data governance. "You can't send company files to OpenAI." The use case dies — not because AI failed, but because there's no governed path to production.
RAG is harder than it looks
Everyone starts with RAG thinking it's solved. Then you hit chunking problems, stale indexes, permission leakage between users, and models confidently hallucinating from the wrong document. Building RAG that actually works at scale is a serious engineering project most teams badly underestimate.
Five things that work
the moment you install
Not a roadmap. Not a beta. Every one of these is live in the container you pull today.
Instant AI API on your existing storage
The moment you run the container and point it at your storage, every file gets a REST API. No migration. No new hardware. No new storage contracts. Your NAS didn't change — it just became agent-ready.
- Works on MacBook, Windows Server, Linux NAS, or enterprise storage
- Auto-indexes directories on connect — no manual setup
- Every file accessible to any agent via standard REST calls
- Upload, download, search, and chat on files through the same API
curl https://localhost:3000/api/v1/directory/get-root-directories \
-H "Authorization: Bearer <token>"
-F "file=@Q4_forecast.xlsx" \
-F "directoryId=dir_8841929"
RAG on your real documents — out of the box
Point any agent at any directory and ask questions against your actual files. Contracts, engineering specs, financials, research — all queryable by any LLM. Permission-aware, in place, always current.
- Ask natural language questions across any directory of files
- Works with any LLM — Claude, GPT-4o, Gemini, or local Ollama models
- Agents only see files the authenticated user is authorized to access
- Index stays current — new files are queryable within seconds
-d '{
"directoryId": "dir_8841929",
"question": "Which contracts renew in Q1 > $500k?",
"selectedModel": "claude-3-5-sonnet@anthropic"
}'
# Same call — swap any model
"selectedModel": "gpt-4o@openai"
"selectedModel": "llama3.1@ollama"
Persistent agent memory and state
Agents stop starting cold. Every session picks up where the last one left off. Memory, work products, and session context are written back through the API to your storage — surviving compute restarts, model swaps, and provider changes.
- Agents write memories as files — readable by any subsequent session
- Shut down GPU between tasks — restart anywhere with full context
- Work products versioned and stored alongside source documents
- Dramatically reduces re-contextualization cost across long-running tasks
curl -X POST .../api/v1/file/upload \
-F "file=@session_memory.json" \
-F "directoryId=agent_state_dir"
# Next session — resume with full context
curl -X POST .../api/v1/genai/chat-on-directory \
-d '{ "directoryId": "agent_state_dir",
"question": "Resume my last task" }'
One governed layer for every agent and every person
Claude, GPT-4o, Gemini, LLaMA, your custom models, and your human team all go through the same Olympus API. Every call is permission-checked against Active Directory. Every access is logged. IT finally has visibility.
- Integrates with Active Directory and LDAP — your existing user directory
- SSO support — agents authenticate as scoped service accounts
- Per-user permission enforcement — agents only see what their user sees
- Full audit log of every file access, every model call, every write
-d '{
"email": "agent-svc@company.com",
"apiKey": "svc_key_xyz"
}'
# Every call appended to immutable audit log
Full model freedom — swap any LLM, any time
Because Olympus sits between your agents and your data, you are never married to a model vendor. Run Claude and GPT simultaneously on the same directory. Switch models with a single parameter.
- Works with Anthropic, OpenAI, Google, Mistral, Meta, and any Ollama model
- Run multiple models simultaneously on the same data
- Switch providers mid-project — agent memory and RAG unaffected
- Local inference via Ollama for fully air-gapped deployments
"selectedModel": "claude-3-5-sonnet@anthropic"
"selectedModel": "gpt-4o@openai"
"selectedModel": "gemini-1.5-pro@google"
# Local / air-gapped (via Ollama)
"selectedModel": "llama3.1@ollama"
"selectedModel": "deepseek-r1@ollama"
Three steps from
zero to agent-ready
No new storage to provision. No data to migrate. No cloud accounts to configure. Deploy Olympus as a container and point it at what you already have.
Run the container
Pull the Github deploy script. Self-contained — no external dependencies, no cloud calls required to start.
docker run · 60 secondsConnect your storage
Point Olympus at your existing storage — SMB share, NFS mount, S3 bucket, or native NetApp/Dell/HPE API. Olympus auto-indexes your directories. Every file immediately RAG-ready through the API.
auto-indexed · no migrationYour agents connect
Any agent — Claude, OpenAI, Gemini, your custom model — authenticates with the Olympus API and immediately has governed, permission-aware, persistent access to all of your real data. Memory persists. Lock-in is gone.
any model · live immediatelydocker pull olympusio/olympus:latest
# ── Step 2: Run with your storage and AD config ─────────────────
docker run -d \
-p 3000:3000 \
-e NAS_HOST=your-nas.company.com \
-e AD_LDAP_URL=ldap://dc.company.com \
-e OLLAMA_HOST=http://gpu-server:11434 \
-e API_KEY=your-api-key \
--name olympus \
olympusio/olympus:latest
# ── Step 3: Authenticate ────────────────────────────────────────
curl -X PUT http://localhost:3000/api/v1/entrance/login \
-d '{ "email": "you@company.com", "apiKey": "your-api-key" }'
# ── Step 4: Browse your storage ─────────────────────────────────
curl http://localhost:3000/api/v1/directory/get-root-directories \
-H "Authorization: Bearer <token>"
# ── Step 5: Run RAG on any directory ────────────────────────────
curl -X POST http://localhost:3000/api/v1/genai/chat-on-directory \
-d '{
"directoryId": "<id from step 4>",
"question": "Summarize key themes across these documents",
"selectedModel": "claude-3-5-sonnet@anthropic"
}'
✓ Your storage is now agent-ready. Every model. Zero egress. Full governance.
Start building
in the next five minutes.
One container. Any storage. Every model. No vendor owns your data layer but you.