Koan
An opinionated, agent-native .NET meta-framework. Add what the business needs; keep the application readable.
Koi
See what is running, give it a stable .internal name, and make it trusted - no accounts, no cloud.
Ghostlight
Your real browser, for any MCP agent - visible, local, and yours.
Zen Garden
Turn spare computers into a small, sovereign service garden. Ask for what you need; Zen Garden tends the machinery beneath it.
Agyo
Opt-in capabilities for Koan. Add more reach without giving the application a second architecture.
os-tools
Small Rust crates: one symmetric API over divergent platform mechanisms.
Hokora
A cognitive-architecture canon for artificial companions.
Nagi
A breathing companion you hold, not watch.
A minute with Koan
From V0 to V1 in meaningful, small steps. Reference only what the use case needs; Koan composes it around the domain and shows what changed.
Start useful
Reference the first capabilities, describe the domain, and run a real web application with storage - without speculative layers.
Add the next need
A new reference brings the next coherent capability into the same application model, with configuration only where the choice needs it.
Read the business
Entities, rules and workflows remain the application. Repeated infrastructure mechanics stay in the framework.
Is this your problem?
- You want a small web application with storage running before scaffolding becomes the project.
- Identity, tenancy, jobs, search or agent access should join when the business case earns them.
- Developers and agents need one compact grammar, with runtime decisions people can inspect.
- You want zero framework coupling or intend to assemble every infrastructure layer yourself.
- Your application depends on behavior outside the capability contracts Koan and its adapters expose.
- You need stable 1.0 compatibility guarantees or a mature commercial ecosystem today.
Composability is the product.
Koan is not a stack every application adopts at once. It is a family of capabilities with one composition model, added in the order the domain and use case require.
Business domain + Web + Storage + Identity + Tenancy + Jobs + Search + MCP
Add only what the use case earns. The boot report, capability set and composition lock explain what each reference contributed.
One experience, understood from every side
For the developer
Business progress per change: each small addition delivers a useful vertical result.
For the agent
More business intent per token: one grammar replaces repository archaeology and invented wiring.
For DevOps
Certainty per deployment: startup, health and composition evidence say what actually assembled.
For the architect
Growth without architectural drift: capabilities join through shared, inspectable boundaries.
Run one real slice
The current supported public path builds from the active source branch. Start the sample, then create and read persisted domain data through its composed web surface.
Now ask the generated entity surface for the data it persisted:
curl http://localhost:4998/api/todo
The response is useful; the startup report and lockfile are the receipts for how it came to be.
Know what you are adopting
- Work in progress: the V1 initiative is consolidating Koan around meaningful incremental growth, a durable Entity contract and explicit acceptance gates.
- The central data, web, cache, jobs, vector and MCP paths already function in current source and carry integration or conformance coverage.
- Pre-1.0: packaging, first use, errors, observability and upgrade guarantees are still being hardened. Build current source and expect movement.
A minute with Koi
See what is running, give selected services stable private names, and add trust when they need it. People, applications and agents can work from the same current picture.
Look before setup
Run one command and see services by what they are. No daemon, account, DNS change or certificate ceremony is required to start.
Name what matters
Turn selected services into stable .internal names, then add private certificates where HTTPS earns the extra trust.
Share current truth
Status, health, events, the dashboard, standard integrations and MCP describe the same local service picture.
Is this your problem?
- You own a development network, homelab, lab or small edge environment and are tired of copied IP addresses.
- Windows hosts or bridge containers need a consistent way to discover and publish local services.
- Private .internal names, trusted HTTPS or agent-readable inventory should work without a cloud control plane.
- You need public internet ingress, enterprise DNS or PKI, fine-grained RBAC, compliance controls or commercial support.
- You need Kubernetes-native identity, cross-VLAN multicast discovery or isolation between hostile tenants.
- You need packet inspection, full metrics and tracing, or immediate network-wide certificate revocation.
Two jobs, one network truth.
Koi instruments the local service layer, then lets that evidence participate in naming and trust. Each capability remains useful alone; the composed result is the reason they belong together.
service appears -> discovered -> named .internal -> optionally trusted -> visible to people and agents
The .internal reservation prevents a future public-TLD collision; Koi still supplies the local DNS authority, forwarding path, private CA and trust distribution that make the name useful.
One experience, understood from every side
For the developer
Network mechanics leave application code: publish what the service offers without rebuilding discovery, naming and cleanup per platform.
For the agent
More environmental truth per token: one bounded inventory replaces port probing, stale host files and network guesswork.
For DevOps
Consolidation without forced replacement: real status, native service management and standard DNS, ACME and Prometheus doors.
For the architect
A bounded local substrate: daemon or embedded, no cloud dependency, explicit authority and candid anti-scope.
Start by looking
Install the current release for your platform, then ask the network one useful question before committing to a daemon, DNS zone or private CA.
Browse the local network now:
koi mdns discover
Discovery runs standalone. If the result earns a permanent place, install the native service and add naming, health, containers or trust in the order the network needs them.
Know what you are adopting
- Released today: v0.9.0 provides cross-platform mDNS, local DNS, certmesh and trust, DNS-01 ACME, health, TLS proxying, Docker/Podman wiring, UDP bridging, dashboard, OpenAPI, Prometheus discovery, MCP and embedded Rust surfaces.
- Pre-1.0: use Koi on small networks you own and expect interfaces to move. It is not enterprise PKI, Kubernetes service discovery, cross-VLAN multicast or packet-level observability.
- Work in progress: the dev branch is refining membership-intrinsic, self-managing trust. Treat that ADR-023 behavior as unreleased until a later version contains it.
A minute with Ghostlight
Give an agent the browser where your work already lives. The work stays in front of you, and a boundary is there when the job needs one.
Ask naturally
Describe the job. Familiar browser tools and useful errors keep the agent moving.
Watch it happen
A dedicated tab group opens in signed-in Chromium. Every action stays visible.
Stay in control
Take over anytime. Boundaries explain themselves; the local record shows what happened.
Is this your problem?
- The agent needs the cookies, SSO or sessions already in your browser.
- You want one browser surface across MCP clients.
- You want visible work, easy recovery and inspectable boundaries.
- You need headless, stealth, bulk or remote-cloud automation.
- No person will be responsible for the browser session.
- Claude's first-party browser integration already fits the entire job.
Useful first. Responsible all the way through.
Ghostlight starts with the job: see the page, act in the browser, and return a compact result. Visibility, boundaries, and evidence belong to that same experience.
MCP client <-> relay <-> local service <-> relay <-> extension <-> Chromium
No vendor service sits in the runtime path. Your browser session stays on your machine.
One experience, understood from every side
For you
One installer and visible, interruptible work.
For the agent
Stable schemas, compact results, and useful recovery guidance.
For reviewers
Local evidence, readable source, and an inspectable boundary.
Try it for real
Let your agent handle setup, or run the installer yourself. Both paths end at the same doctor check.
Check the whole chain
Doctor names anything missing.
Open https://sylin.org/ghostlight/demo/form/. Fill the form with the name Test Gardener, the email [email protected], the Developer role, and the message First light. Submit it, then tell me exactly what confirmation appears. Stay on sylin.org.
Nothing is sent or stored.
Know what you are adopting
- Pre-1.0: the trained browser schemas are stable; surrounding interfaces may evolve.
- Windows is live verified. macOS and Linux are CI green; live-browser verification is owed.
- The Chrome Web Store listing is submitted and pending compliance review; the install guide provides the current extension path.
A minute with Zen Garden
A spare computer becomes a named Stone. Ask the garden for MongoDB and it handles the manifest, hardware fit, storage, port and published connection details while the application stays about its own work.
Prepare a Stone
Boot the garden installer on a spare machine. It receives a name, an identity and a place in the garden.
Offer what you need
Name the service. A checked-in manifest carries the operational knowledge for selecting, placing and starting it.
Find it by meaning
Ask for MongoDB, not a remembered box. Rake returns the current location and a connection URI for people, scripts or agents.
Useful machines, working together.
Is this your problem?
- You have thin clients, retired PCs or other capable machines that should be useful instead of becoming e-waste.
- You want a handful of self-hosted services without hand-maintaining container commands, ports and hostnames.
- You value local ownership, comprehensible infrastructure and the freedom to replace individual machines.
- You need a managed service, contractual availability or commercial support.
- You need production high availability, general cross-Stone state replication or automatic disaster recovery today.
- You are operating a large, hostile multi-tenant estate that calls for enterprise orchestration and policy controls.
Useful hardware, tended as one garden.
Zen Garden starts with service intent, then carries that intent through placement, operation and discovery. The container is disposable; the offering name, configuration, data location, port and discoverability are what the garden remembers.
What's inside
spare machine -> named Stone -> offer manifest -> Moss -> running service -> connection URI
Moss tends the runtime on each Stone. Rake, scripts and agents inspect the same garden; Koan applications can resolve zengarden:// resources into current connection strings.
One experience, understood from every side
For the builder
One service-shaped request replaces a page of container, storage, port and discovery plumbing.
For the agent
Compact commands plus JSON and URI output keep infrastructure work legible and composable.
For the operator
Pulse, health, events, logs and visible companions make the garden observable in software and in the room.
For the inheritor
Named offerings and checked-in manifests preserve why a service exists after its original machine is gone.
Grow one useful thing
Once a Stone is running Moss, two commands turn service intent into something an application can use.
Open the live terminal view when you want the whole garden in sight:
garden-rake pulse
Pulse makes Stones, offerings and current state visible without turning ordinary service use into an operations dashboard.
Know what you are adopting
- Active development: the offering lifecycle, discovery, operations and companion surfaces are exercised on a real heterogeneous garden and are testable from source.
- The current USB creator builds an unattended Stone installer, but a signed turnkey image or downloadable installer bundle is not published yet.
- Moss can reconstruct a missing managed container on a surviving Stone. General cross-Stone state recovery, guarded update rollback and production high availability remain active work.
A minute with Agyo
When a Koan application needs GraphQL, scheduling, vector search, RAG or another advanced capability, add that intent without introducing a second framework around the domain.
Name the capability
The reference says what the application needs. Agyo carries the recurring registration, lifecycle and provider mechanics.
Keep one application
Entities, hooks, configuration and business behavior stay in Koan's familiar grammar instead of splitting into another integration layer.
See what joined
Capabilities participate in Koan's startup and operational vocabulary, so optional composition can remain inspectable.
Is this your problem?
- A Koan application needs an advanced capability without a parallel bootstrap, domain model or provider vocabulary.
- A small application should gain something substantial without letting integration plumbing dominate its code.
- Optional dependencies and their security cadence should remain outside Koan core until an application asks for them.
- The application is not built on Koan or the team wants zero framework coupling.
- You need stable public packages, compatibility guarantees and a mature support ecosystem today.
- You need durable distributed scheduling, a fully typed production GraphQL schema, or turnkey hosted RAG now.
Capability without a second architecture.
Agyo is where useful Koan-native capabilities can grow independently. Applications reference only what they need; the foundation stays lean and the resulting system stays recognizable.
What's inside
Koan application + chosen Agyo capability -> AddKoan() -> one composed runtime
Agyo depends on Koan's public packages; Koan never depends on Agyo. That one-way boundary keeps every capability optional and gives it an independent release and security cadence.
One experience, understood from every side
For the developer
Meaningful capability without integration sprawl: the remaining code stays about the application's work.
For the agent
More optional intent per token: a known package and one composition grammar replace invented wiring.
For DevOps
Optional operational weight with visible dependencies, health, provider choices and safe defaults.
For the architect
A controlled capability frontier that lets Koan remain coherent without becoming monolithic.
Follow Agyo toward V1
The capability source is implemented and testable today. Public package installation and compatibility guarantees are part of the V1 stabilization work.
Know what you are adopting
- Building toward V1: twelve library projects pack from source, the principal composition paths have focused tests, and Librarian demonstrates a substantial runnable service assembled from Agyo capabilities.
- Not public yet: the first Sylin.Agyo.* NuGet release and a clean package-first onboarding path are still part of the V1 work. Follow the source now; do not treat package IDs or APIs as stable.
- The boundaries are deliberate: scheduling is in-process, GraphQL typing is still limited, external AI/vector/Vault behavior needs its providers, and the full tool-using RAG retrieval loop remains future work.
What it actually does
Small, dependency-light Rust crates that each present one identical API over the platform-native mechanism beneath - the same operation, done the same way, on Windows, macOS and Linux. The first is os-truststore: it installs a root certificate into the OS trust store, where the established crates in this space only read from it.
The concept
What's inside
What it is
A research canon, not software: an architecture paper, a glossary, a graded bibliography and a stack of decision records for how an artificial companion might remember, attend, and hold a coherent sense of self over time.
The concept
What it is
A paced-breathing companion built to be held rather than watched. A tuned, runnable prototype exists today; the shippable app does not yet.