// 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.

~/Agents/Oppi

The folder

  • AGENTS.md
  • SOUL.md · IDENTITY.md · USER.md
  • knowledge/
  • index.md
  • memory/index.md
  • raw/sessions/2026-11-09.md
  • projects/
  • TASKS.md
  • acme-app/tasks/ac-102-checkout-total.md
  • dashboard.html

$ 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.

  1. 01

    Sessions

    Every conversation, saved when it ends.

    ↓ capture

  2. 02

    Knowledge

    Compiled into notes it reads before you type.

    ↓ informs

  3. 03

    Projects

    Tasks and plans it keeps current.

    ↓ generate

  4. 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.

// 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.

cmux with three agents, Oppi, Nova and Scout, and the sidebar on the Manager: sessions that need you on top, then the ones running

// 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 | bash

Paste 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.

Read the docs →