Oystro OSS live · Oystro Standard soon

The layer above your agents.

AI agents work fast and tireless - but each one sees only its own slice, and every session starts from zero. You become the memory. Oystro sits above them all: one process, one memory, one view, so the work ships - without locking you into a single tool.

--
Days
:
--
Hours
:
--
Minutes
:
--
Seconds
Paid engine: first access at launch.
Try the open source now →
Scroll
The Stake in the Ground

Your process. Every agent.

Every agent vendor wants you locked into their tool: their agent, their model, their workflow. But the model isn't the fix. It's not the model - it's the harness. The model gets you speed; the harness gets you trust. Oystro is agent-agnostic: the workflow is the constant, the agent is interchangeable.

Vibe Coding

The agent agrees with you, and neither of you notices.

Decisions happen in the prompt, invisible and unaudited. The agent fills missing context with plausible guesses that look right. Weeks later, the whole feature is built on a wrong assumption, and you only find out when it ships.

  • ✕No project memory across sessions
  • ✕No gates, no moment to stop and check
  • ✕Confident wrong answers, at speed
→
Harness Engineering

The agent stops at every human gate.

You review the design before a line of code is written. You approve the contract. Then the agent executes, one task at a time, no improvisation, every decision recorded. What you approve is what ships.

  • ✓Durable memory across every session
  • ✓Verification gates with real evidence
  • ✓Traceable work you can audit and trust
Our enemy is not bad code. It's the belief that you have to pick one agent and trust it completely. That's what produces confident wrong answers at speed.
Free & open · Oystro OSS

The protocol is live. Start today.

No need to wait for the paid launch to get value. Oystro OSS is the protocol itself, open source and running now: the workflow, templates, and rules. File-based and agent-agnostic, with no runtime, no account, and no API keys. The paid engine, Oystro Standard, adds the memory and the enforced gates that make it dependable.

Init
Constitution · BRD · Architecture
→
Define
One spec.yaml: requirements + design + tasks
→
✋ Gate 1
You approve the spec before build
→
Build
One commit per task · no improvising
→
Review
Fresh-eyes agent review · L only
→
Verify
Evidence · acceptance criteria
→
✋ Gate 2
You approve the release

S, M, or L sets how much ceremony a change gets - a config tweak doesn't need a full review; a schema change does. You opt into speed; the process doesn't force it.

Specialist agents (Manager, Analyst, Developer, Reviewer, Gatekeeper) each with a bounded role. None of them can approve the work. That's yours. Approve, and the release ships.

The workflow

/oystro:init → /oystro:define → [Gate 1: /oystro:approve]
  → /oystro:build → [/oystro:review-pre-verify · L only]
  → /oystro:verify → [Gate 2: /oystro:release]
/oystro:initScan docs, derive constitution, BRD, architecture. /oystro:defineCreate one spec.yaml: requirements, design, tasks. /oystro:approveGate 1. Approve the spec before any code is written. /oystro:buildImplement against the approved contract. One commit per task. /oystro:verifyRun the evidence, check acceptance criteria. /oystro:releaseGate 2. Approve the release.

Try it. Two minutes.

read https://github.com/oystro/oystro-oss/blob/main/commands/init.md
# and follow the instructions to initialize oystro-oss in this folder

The scaffold appears: constitution, BRD, architecture. Then start defining features. Works with any agent that can read and write files.

Why Oystro

Your process, above every agent.

You don't have to trust any single agent - you trust the layer above them. The agents do the work. Oystro keeps the truth. The protocol (Oystro OSS) runs free today; the engine that enforces and remembers it (Oystro Standard) is what you add.

Durable project memory

Agents forget everything between sessions. The engine keeps decisions, evidence, and progress, so any session resumes in seconds, with any agent.

Protocol + engine

Verification gates & evidence

The protocol defines the gates; the human is the enforcement point. The engine makes them deterministic and captures the evidence. The gate is real: it can block.

Right model, right job

Oystro Switch routes routine work to a fast, low-cost provider and reserves premium models for architecture and hard problems.

Open source

Agent-agnostic by design

Claude, Cursor, Codex, Copilot, or whatever comes next. Bring any agent. Keep your standards. Swap agents; the workflow stays.

Resume in minutes

Multi-week projects never lose the thread. A compact handover brings a new session back up to speed, for roughly 85% fewer tokens than a full replay.

Open source

Traceability without ceremony

Every commit tells the story of what was built and why. Six months later, git log tells you exactly what happened, no guessing.

In motion

How the protocol actually behaves.

Six moments that separate a demo from a process: the project remembers, the plan stops for you, the proof stops for you, and every decision leaves a trail.

Init/oystro:init
The project remembersA new session resumes from the repo, not from zero.
Gate 1/oystro:approve
Nothing gets built without youGate 1: you approve the plan before any code is written.
Gate 2/oystro:release
Nothing ships without proofGate 2: you approve the evidence before release.
Build/oystro:build
One task, one commitSerial, disciplined execution - not parallel chaos.
The workflow
ClaudeCopilotCursorCodex
Any agentno lock-in
Bring any agentKeep your process. The agent is interchangeable; the workflow isn't.
TraceableSLICE_LOG.md
Every decision links to whyThe spec, the task, and the proof stay connected to the change.
Watch

Two minutes to the idea. Then watch it run.

The concept first: why agent speed without a harness produces confident wrong answers. Then a live run of the full workflow - real gates firing, real evidence, start to ship.

Concept - It's not the model. It's the harness. Human gates for AI coding agents.
Show transcript

AI writes software faster than any team alive. It can also be confidently wrong just as fast. An agent agrees with an incomplete plan, then builds at speed. The reasoning lives in chat and scrolls away. The steps nobody watches get skipped, and every session starts from zero. So, the memory of the project becomes you. We keep reaching for a smarter model, but this isn't a model problem. It's a structure problem, and you can't fix a structure problem. And you can't fix a structure problem with a smarter model. So, Oystro wraps structure around the agent, a harness, not a tool, not a plugin, a process written down that any agent can follow. The idea is simple. The agent is fast and tireless, but it can't see its own blind spots. So, instead of asking it to check itself, the process stops and puts the work in front of you. A moment where you step in and decide. That's what a gate is. Follow the flow. In it, scaffolds the project. Define writes the plan, the spec, the tasks, the acceptance criteria, and then it stops. This is gate one. You read the plan. You fix what's wrong. You approve it. Nothing gets built until you do. Build implements it. One task, one commit. For larger projects, a fresh eyes review runs against the plan with no memory of the build, so it can't rationalize its own choices. Then verify runs the evidence. Then gate two. You see the proof and the deferred items, and you approve the release. And when the next feature comes, it loops back to define. Now, look at the middle, because this is the part people miss. Once the plan is approved, you're not in the loop for every step. Between the gates, the agent works on its own, building, verifying, recording without your intervention. You come back at the gates, approve the plan before code, approve the release after the proof. Two moments are yours. Everything in between belongs to the agent. And it leaves a trail. Months later, anyone can see what changed, why, and what proved it. Every decision linked to the work it caused and the proof it passed. The same harness handles the small stuff, too. Bugs and change requests take a lighter path without the full ceremony. The agent is interchangeable. The process isn't. Use your agent today, a different one tomorrow. The workflow doesn't change. That's Oystro, your process, every agent today.

Live demo - AI writes the code. You hold the gates. The full workflow, recorded live.
Show transcript

Hope you're here after watching the Oystro concept video. Hi everyone, I'm George Koshy. Welcome to the live demo of Oystro OSS, a full life cycle software engineering protocol for AI coding agents. Let me show you. This project is empty, so let me start my agent. This is OpenCode, the agent I'll be driving. I go to the Oystro open source repo, copy the init command, and paste it in. What it does, it scans the repo and scaffolds it, the constitution, the architecture, the build log. These are real files in your repo, not in your chat. The next permitted command is Oystro define. This is where we define the project. So now it's come to the first human gate. Here you have a chance to read the plan, fix what's wrong, and approve, because nothing is built until this. Now that we've approved it, the next step is the build step, where we go one task at a time, one commit per task, no improvising over here. It's time for Oystro verify. What it will do here is run the evidence, the tests, the acceptance criteria, and the verification report. This is where you come to the second gate, where you can read the evidence and approve the release. There's a read me as well as the release notes. You'll see what the deferred items are, they're disclosed over here, and then it gets merged. You can come back after 6 months, and the entire build narrative will tell you what changed, why, and what proved it. The agent is interchangeable, but the workflow isn't. Bring any agent, keep your standards. It's free and open source, file-based with no account required. Try it on a real project and tell me where it breaks. github.com/oystro/oystro-oss. Let me do one more thing. I forgot to do this. Let's just check what's been built. This is what's been created in the first defined phase. We could kind of beautify it, for example, if I'd started the defined phase by saying, "Let me have a Shopify-style storefront with placeholder images." It would have been built to that specification. But, thank you. Try it on your project and tell me how it works for you.

Coming · Oystro Standard (paid engine)

The protocol is free. Oystro Standard is the engine.

Oystro Standard is the paid engine for one engineer: command-line tools, project memory, a code map, and enforced gates, plus a local dashboard (Oystro Visualizer). This is what we are shipping next; team and enterprise layers follow.

Launching soon

Enforced gates

The protocol defines the gates; the engine enforces them. Prerequisite checks, approval state, no skipped steps. The gate can actually block.

Launching soon

Evidence you can check

Every "done" carries proof tied to the exact commit. Fail closed: no evidence means failed, never a silent pass.

Launching soon

Oystro Graph

Know what a change will touch before you make it. A living map of the project, so refactoring stops being a gamble.

Launching soon

Oystro Search

Find code, plans, decisions, and evidence by meaning, not just exact names. One place to look, always current.

Launching soon

Oystro Vec

The project's memory. Ask why something was built a certain way and get the real decision, months or years later.

Launching soon

Oystro Switch

The right model for the job. Spend on the hard parts, not on busywork, without quietly lowering quality.

Questions

Common questions.

What is Oystro?

Oystro is a full-lifecycle software engineering protocol for AI coding agents: human approval gates and project memory above your agents, so long projects stay reviewable and maintainable. The agent works autonomously, but it stops at two points for a person to approve: the plan before any code is written, and the release before it ships. Every decision and every test result is recorded with the project.

Is Oystro free?

The protocol itself is free and open source (Oystro OSS): the workflow, templates, rules, and command contracts, file-based with no runtime and no account. The engine that enforces the gates and keeps the memory (Oystro Standard) is paid.

Which AI agents does Oystro work with?

Any agent that can read and write files: Claude, Codex, Cursor, Copilot, OpenCode, Gemini, or whatever comes next. The workflow is the constant; the agent is interchangeable.

How is Oystro different from vibe coding?

In vibe coding, the agent generates and you accept or reject after the fact. In Oystro, the agent stops before it writes code: you approve the plan first, then review the evidence before release. The difference is who is in control.

Will Oystro make my project more maintainable?

Yes, by keeping the reasoning with the code. Every change is one commit tied to an approved plan, and the build narrative records what changed, why, and what proved it. Months later, you can still explain why the code works the way it does.

Does it work on existing code, or only new projects?

Both. Point it at an existing repo and the agent reverse-engineers the architecture from what's actually there - constitution, boundaries, the pieces a new dev would trip on. Then every new change runs through the same gates, verified against your existing tests.

What is the difference between Oystro OSS and Oystro Standard?

Oystro OSS is the protocol reference: the method, as files you copy into your project. Oystro Standard is the engine: enforced gates, evidence capture, project memory and a code map, and a local dashboard. Start free with the protocol; add the engine when you want it enforced.

How much does Oystro cost?

Oystro OSS — the protocol, workflow, templates and rules — is free and open source: file-based, no account, no API keys. Oystro Standard, the paid engine, launches on December 1, 2026; waitlist members get founding-member launch pricing and first access.

How do I install Oystro?

There is nothing to install. Open your AI agent in your project and paste one command: read https://github.com/oystro/oystro-oss/blob/main/commands/init.md and follow the instructions to initialize oystro-oss in this folder. It scaffolds the protocol into your repo — on an empty folder or an existing codebase alike.

Is Oystro production-ready?

Oystro OSS is live today and runs on real projects: the workflow, templates and gates are free and usable now. Oystro Standard — enforced gates, evidence capture, project memory, dashboard — ships on December 1, 2026. Try the OSS on your own code and judge it there.

George, founder of Oystro
Who's building this

Hey - I am George.

I am building Oystro because AI coding agents are fast, but fast without oversight is how projects drift from what anyone actually approved. I want work you can review, audit, and stand behind: human gates, recorded decisions, evidence with every change. Watch the demo and leave a comment - I reply there - or DM me on X.

Be First In Line

Oystro Standard launches soon.

Join the waitlist and we'll email you the moment the engine goes live. Founding members get launch pricing, first access, and a say in what we build next.

No spam. One email at launch. Unsubscribe anytime.