// How it works
It remembers. It follows your rules. It does the work.
Three parts, built in that order. Each one is plain files in a folder you own, so you can read what your agent knows, change how it behaves, and take all of it with you.
The folder
- AGENTS.mdoperating manual
- SOUL.md · IDENTITY.md · USER.mdwho it is, who you are
- knowledge/
- index.mdthe wiki
- memory/index.mdwhat is active now
- raw/sessions/2026-11-09.mdcaptured tonight
- projects/
- TASKS.mdthe board
- acme-app/tasks/ac-102-checkout-total.md
- dashboard.htmlone file
$ cd ~/Agents/Oppi && claude
▸ session start · Oppi
- loadedwho it isSOUL · IDENTITY · AGENTS.md
- loadedwho you areUSER.md
- loadedthe brainknowledge/index · memory/index
- loadedthe boardprojects/TASKS.md · 9 open
- loadedthe lessons12 corrections, compiled
- loadedthe traillast session · 3 commits since
context primed · 6/6
> what needs me today?
Three things. The checkout total (ac-102) is due tomorrow; Scout
has the tests running. Two partial-refund tickets wait on your reply,
and I drafted both. The invoice export (ac-101) is two days overdue,
so I moved it to tomorrow and told the customer Wednesday.
2 replies drafted · waiting on you
// A fresh launch for every question. Six things loaded before the first prompt. Nobody pasted any context.
01
Sessions
Every conversation, saved when it ends.
↓ capture
02
Knowledge
Compiled into notes it reads before you type.
↓ informs
03
Projects
Tasks and plans it keeps current.
↓ generate
04
Results
Briefs, reviews and shipped work.
↓ feeds the next session ↺
Every session is captured on exit. Captured sessions compile into a wiki. The wiki loads before you type a word in the next session. Everything else is built around that loop: the skills and tools feed it and act on what it knows.
// Three parts · one order
The brain, then the rails, then the skills.
That is the product, and it is also the order it gets built in. Each part ships with a head start. Each gets tuned to you on top.
The brain
What your company knows, compiled.
Identity, operating manual, knowledge, memory, tasks: everything the business knows, captured from real work and compiled into files an agent can load before it starts. Your codebases carry their own.
- Seeded
- The brain architecture, the capture and compile pipeline, a seed bundle from eleven prompts.
- Tuned
- Your corpus seeded in, your capture sources wired, your manual and rules written for how you actually work, and your codebases made agent-ready.
/how-it-works →
The rails
The rules that make any model safe to work with.
An agent that loads the context every session and runs inside the host you already use, with the rails a business needs: permissions, hooks, an audit trail, a dashboard. The model is a setting.
- Seeded
- The open-source agent, host-neutral, running in production daily.
- Tuned
- Works under your keys, named (Oppi, or your own), permission rails set to your data classification, wired into your workflow.
/how-it-works#rails →
Skills and packs
Skills it can run and tools it can reach.
What the agent can do and what it can reach. Capability packs are open and horizontal. Industry modules bundle the packs, skills, and regulatory knowledge one sector needs.
- Seeded
- 30+ skills, 70+ playbooks, 80+ tools, 9 packs, 5 industry modules.
- Tuned
- Your own skills and tools: the functions, data, and workflows only your company has.
/modules →
// Brain → rails → skills · every part: a head start, then yours
// What it is
An agent with a memory, a manual and a job.
01
It remembers.
Every session is captured when it ends and compiled into a wiki. The wiki loads before your first prompt in the next one. No "as I mentioned last time", no pasting context.
▸ capture → compile → load, every session
02
Everything is a file.
Its character, its memory, your projects, your tasks: plain markdown in one folder on your disk. Browse it in Obsidian, commit it to git, grep it, take it with you if you ever leave.
▸ no database, no lock-in
03
Runs where you already work.
A plugin for Claude Code or Codex. One folder works from either. No new app, no new account, no metered API key: your session does the thinking on the subscription you already pay for.
▸ claude · codex · one home
04
Projects, not chats.
One markdown file per task with frontmatter, a checklist, and a thread. A board and a dashboard regenerate from them: one static HTML file, no server, opens anywhere.
▸ tasks/co-014-retry-webhooks.md
05
Wired into your systems.
80+ tools out of the box: tasks, knowledge, worktrees, GitHub review and issues, a support helpdesk, App Store reviews, database queries, a headless browser, web search, page speed, Search Console. Packs switch on when you add a credential.
▸ SEO · Browser · Database · GitHub · API · Xcode · Helpdesk · App Store · Slack
06
Private by construction.
Local by default. Secrets sit in a deny-gated store its own tools cannot read, transcripts are redacted before they persist, and nothing leaves the machine unless you commit the folder somewhere.
▸ your keys, your disk, Apache-2.0
// The rails
It follows your rules. The model is a setting.
What makes an agent effective in a business is not which model answers. It is what the agent knows before it starts, what it is allowed to do, and what gets recorded. Those live in files around the model, and they are what ships.
Operating manual
One file says how the agent works, what it may do, and how you like to work. Every host reads it at session start.
Permission rails
Allow and deny lists, a sandboxed shell, and secrets in a store its own tools cannot read. Set to your data classification, not to a default.
Hooks
Session start loads the context. Session end captures it. A guard checks every shell command before it runs. Skills advise; hooks enforce.
Audit trail
Every session captured to a dated file, every task change threaded, the whole folder under git. Who asked, what it did, what was decided.
Observability
A dashboard of today, the board, sessions, and reports, plus a radar of what every running session is doing and where it left off.
Host-neutral
Claude Code today, Codex today, the next host when it ships. One folder works from any of them. The model is a setting.
// Open source as agentlayer, Apache-2.0 · running in production daily · extended in every deployment
// The radar
Many agents. One radar.
Every session is a file, so every session can be watched. The Manager in the sidebar shows what each agent is doing across every home, sorts it into needs you, running, recent and idle, and takes you to it in one click. You never hunt for the stuck one.

// Three agents, one window. Five sessions need you, five are running. Demo data for a fictitious company.
// Open foundation · private recipes
The head start is the same for everyone. What compounds on top is yours.
Everything we ship is open source and self-hosted. Everything we tune is your company’s own and never leaves your infrastructure. Forward-deployed engineers do the tuning, layer by layer.
01 · What it knows
The brain
Ships
The brain architecture, the capture and compile pipeline, a seed bundle from eleven prompts.
Tuned
Your corpus seeded in, your capture sources wired, your manual and rules written for how you actually work, and your codebases made agent-ready.
02 · How it behaves
The rails
Ships
The open-source agent, host-neutral, running in production daily.
Tuned
Works under your keys, named (Oppi, or your own), permission rails set to your data classification, wired into your workflow.
03 · What it can do
Skills and packs
Ships
30+ skills, 70+ playbooks, 80+ tools, 9 packs, 5 industry modules.
Tuned
Your own skills and tools: the functions, data, and workflows only your company has.
Give it a folder.
One line, a few questions, and it wakes up as Oppi, or whatever you call it, with your first project. Everything it learns from there is yours.
▸ curl -fsSL https://agentlayer.one/install.sh | bashPaste into Terminal on macOS or Linux (on Windows, PowerShell takes irm https://agentlayer.one/install.ps1 | iex). It checks each step, shows you what to run, and installs nothing itself.