Skip to content

Code Ownership Model

This document defines ConnectSoft's layered IP model that clearly separates ownership of different code types. It is written for architects, legal reviewers, sales, and anyone discussing contracts with customers.

ConnectSoft uses a layered IP model that balances customer ownership rights with ConnectSoft's IP protection. This model is critical for customer trust, competitive differentiation, and legal clarity in contracts.

Important

Customers always own the code generated into their own Azure DevOps repositories. ConnectSoft retains ownership of the Factory runtime, templates, and libraries used to generate that code, but the generated output itself belongs entirely to the customer.

Layers of Code & Assets

The ConnectSoft ecosystem consists of four distinct layers, each with different ownership:

  1. Factory Runtime - Core platform (orchestrator, agents, knowledge system)
  2. Templates & Libraries - Reusable templates and library components
  3. SaaS Platforms - Productized services (Identity, Audit, Config, Bot)
  4. Customer-Generated Artifacts - Code, pipelines, docs generated into customer repos

Who Owns What

Factory Runtime (Core Platform)

Ownership: ConnectSoft retains full IP

Status: Proprietary, closed-source

Components: - Orchestrator, agent host, schedulers - UI/console (projects, runs, logs) - Internal services: knowledge store, vector index, policy engine - Agent orchestration logic, planning, evaluation

Licensing: - Hosted SaaS (ConnectSoft runs it) - Enterprise on-prem/self-hosted under commercial license

Customer Rights: Customers can use the Factory, but not fork or resell the Factory itself.

Templates & Libraries

Ownership: Mixed (ConnectSoft owns IP, but some components are open-source)

Open Components: - Base microservice template (without premium plugins) - Core ConnectSoft.Extensions building blocks: - Logging helpers - HTTP/OAuth2/OpenID client helpers - OpenTelemetry wiring - Basic DevOps pipeline templates (stripped-down versions)

Closed Components: - Advanced templates (multi-tenant SaaS template, complex EDA setups) - Specialized vertical templates (Insurance BCs, VetCare BCs, etc.) - Premium libraries: - Compliance & redaction - Governance & policy-as-code - Advanced agent blueprints

Licensing: - Open components: MIT/Apache 2 or similar permissive license - Closed components: Commercial license, bundled into paid tiers or marketplace items

Principle: Use open templates to boost trust and adoption, keep the "superpowers" and vertical accelerators as paid/proprietary content.

SaaS Platforms (Identity/Audit/Config/Bot)

Ownership: ConnectSoft retains IP

Status: Closed-source (initially)

Deployment Models: - Hosted SaaS on connectsoft.io (code fully closed) - Optional self-host license for enterprise (read-only repo or package)

Customer Rights: - Use platforms via APIs and UI - Self-host under license (enterprise option) - Cannot fork or redistribute platform code

Future Option: Move some parts to open-core model if community play makes sense.

Customer-Generated Code

Ownership: 100% Customer-owned

Status: Fully owned by customer

Components: - Everything the Factory generates into customer's Azure DevOps - Repos, branches, PRs, work items, pipelines, docs - Generated C# microservices, tests, YAML pipelines, documentation

Customer Rights: - Fork it - Modify it - Move it to GitHub/Bitbucket - Stop using Factory and keep code forever - Copy and adapt freely inside their organization

Licensing: No special restrictions on output. Contract states:

"ConnectSoft retains IP in the Factory and templates. All code and artifacts generated into the Customer's repositories belong to the Customer, except for any pre-existing ConnectSoft source or libraries referenced under their own licenses."

Important Nuance: Customers may reference ConnectSoft NuGet packages (e.g., ConnectSoft.Extensions.*), which remain under ConnectSoft's package license. That's normal: they own their code, we own our libs.

How This Aligns with Customer Expectations

No Lock-In at Code Level

Customers own all generated code. They can: - Stop using the Factory and keep all code - Move code to different repositories or platforms - Modify code without restrictions - Use code indefinitely, even after subscription ends

This is a huge competitive advantage vs low-code platforms and closed systems.

Normal Library Dependency Model

Customers reference ConnectSoft NuGet packages (e.g., ConnectSoft.Extensions.Logging) in their generated code. This is the standard library dependency model: - Customer owns their code - ConnectSoft owns the libraries - Customer depends on libraries via NuGet packages - Libraries are versioned and can be updated independently

This is familiar and acceptable to enterprise customers.

Examples

Example 1: Customer Copies a Generated Microservice

Scenario: Customer generates a Billing microservice, then copies it to create a similar Payments microservice

Ownership: Both microservices belong to the customer. They can copy, modify, and use them freely.

ConnectSoft IP: Factory runtime and templates remain ConnectSoft's IP. Customer cannot redistribute templates or build a competing factory.

Value: Customer gets code ownership, but still benefits from Factory for consistency, upgrades, and support.

Example 2: Customer Stops Using Factory but Keeps Code

Scenario: Customer generates 10 microservices over 6 months, then cancels Factory subscription

Ownership: All 10 microservices belong to the customer. They can continue using, modifying, and deploying them indefinitely.

Limitations: Customer loses access to: - Factory console and new generations - Template updates and improvements - Factory support and guidance

Value: Customer has no vendor lock-in. They own their code and can continue using it forever.

Example 3: Customer Uses NuGet Packages in Their Own Services

Scenario: Customer generates services using Factory, then builds additional services manually that reference ConnectSoft.Extensions.* packages

Ownership: - Generated services: Customer-owned - Manually-built services: Customer-owned - ConnectSoft.Extensions.* packages: ConnectSoft-owned (standard NuGet license)

Value: Customer can extend Factory-generated code with their own services, using ConnectSoft libraries for consistency.

Relationship to Legal/Contract Documents

This document expresses the conceptual model of code ownership. For formal legal terms:

Warning

This document describes the business model, not legal terms. All contracts should be reviewed by legal counsel before execution. The formal policy in the Governance section should be used for contract language.