Standards Surface

Four families of specifications. LogicSRC defines the shared language; products implement it without owning the standard.

${FAMILIES.map((family) => `

${family.name}

${family.line}.

${familyTree(family).map(({ spec }) => `${spec.name}`).join(" · ")}

`).join("")}

Every spec, by family →

AgentSwarm

An open spec AI agent platform for routing work across models, tools, providers, and repositories.

slug: agent-swarm

Provider-neutral agent orchestration

LogicSRC is adding model-provider integration primitives so a CLI or agent runtime can switch between major AI models, choose the cheapest capable option, or rotate models automatically for resilience and cost control.

logicsrc agentswarm --yolo \\
  --repo profullstack/logicsrc \\
  --agents reproduce,patch,review

${upcoming.map((item) => `

${item.name}

${item.detail}

`).join("")}

OpenOntology

An open contract for durable, source-backed domain knowledge shared by humans and AI agents.

Define the things in a domain, connect them with typed claims, preserve where each fact came from, and let agents query or propose changes through governed interfaces. Storage-agnostic, model-provider-neutral, and usable with no account.

Read the specification Explore the example

Five nouns

Type       Person, Project, Codebase
Entity     eth:person:avery-lindqvist
Claim      Avery --worksOn--> ZK Prover
Source     the commit it came from
ChangeSet  a reviewable proposal

Claims are append-only. Agents propose; humans apply.

AgentByte

A coming-soon LogicSRC plugin spec for AI-era screening, assessments, interviews, and auditable agent-assisted answers.

slug: agentbyte

Screening where AI use is declared, measured, and auditable

AgentByte defines open screening sessions for humans, AI-assisted humans, autonomous agents, and human-agent pairs. Instead of pretending AI is absent, the spec records model use, tools, artifacts, scorecards, policy decisions, and evidence.

logicsrc agentbyte plan create \\
  --role "AI Engineer" \\
  --repo profullstack/logicsrc

logicsrc agentbyte session audit \\
  --session ssn_123 \\
  --format markdown

${agentByteSurfaces.map((item) => `

${item.name}

${item.detail}

`).join("")}

Open Schemas

Versioned JSON Schema files are the contract source for tasks, agents, runs, events, and plugins.

${schemas.map((schema) => `

${schema.name} ${schema.path}

`).join("")}

CLI Validation

npm install
npm run schemas:validate
npm --workspace @logicsrc/cli run dev -- \\
  task validate ./task.yaml

The CLI belongs here as standards tooling: validate schemas, inspect objects, drive SDK/TUI/PWA/MCP contracts, and exercise compatible implementations.

Credential Sharing

An available LogicSRC OpenSpec for replacing closed credential-sharing workflows with auditable, provider-neutral secret sync — including end-to-end-encrypted team vaults you can share by email. Shipped in @logicsrc/plugin-credential-sharing.

slug: credential-sharing

Open replacement architecture for secrets

LogicSRC defines the credential source, target, diff, approval, sync, rollback, and audit objects. External tools can consume the contract, but LogicSRC remains the open standards CLI and does not call out to proprietary product commands.

logicsrc credentials providers
logicsrc credentials diff --from env --from-path .env --to railway \\
  --to-project <projectId> --to-config <environmentId>
logicsrc credentials plan --from env --from-path .env --to doppler \\
  --to-project <project> --to-config <config>
logicsrc credentials sync --plan <planId>            # dry-run, no writes
logicsrc credentials sync --plan <planId> --approve  # writes to the target
logicsrc credentials audit --run <runId> --format markdown
logicsrc credentials rollback --run <runId>

Team sharing, end to end encrypted

Teams ship today. The server is a zero-knowledge relay for secret values: it stores member X25519 public keys, the vault data-encryption key sealed once per member, and ciphertext. Plaintext values and the raw DEK never leave a member’s machine, and granting access re-seals the key to the new member rather than revealing it. When someone leaves, rotation re-keys the vault and drops their access.

logicsrc login                                   # registers this device's identity key
logicsrc teams create acme --name "Acme Inc"
logicsrc teams push acme web prod --env .env     # encrypt + upload
logicsrc teams invite acme teammate@example.com  # emails an accept link
logicsrc teams grant acme web prod teammate@example.com
logicsrc teams pull acme web prod --env .env     # download + decrypt
logicsrc credentials rotate acme web prod --approve

SSH keys, not just environment variables

Not every secret is a KEY=VALUE line. ~/.ssh is a directory of files whose permission bits are load-bearing — a private key restored world-readable is one OpenSSH will refuse to use. The ssh provider moves that directory through the same end-to-end-encrypted vault as everything else and puts each file back with its mode intact, so a new machine is set up rather than merely populated. Restored SSH keys can go straight into ssh-agent instead of onto disk.

logicsrc secrets ssh push profullstack   # back up ~/.ssh to vault ssh--<you>
logicsrc secrets ssh list profullstack   # what the vault holds: paths, kinds, modes
logicsrc secrets ssh pull profullstack   # restore on another machine, permissions and all
logicsrc secrets ssh agent profullstack  # load into ssh-agent, never onto disk

${credentialProviders.map((item) => `

${item.name}

${item.detail}

`).join("")}

${credentialSurfaces.map((item) => `

${item.name}

${item.detail}

`).join("")}

LogicSRC vs OpenSpec.dev

OpenSpec.dev is adjacent: it focuses on lightweight repo-local planning artifacts. LogicSRC is the broader coordination standard and can support OpenSpec-compatible workflows.

Area LogicSRC.com OpenSpec.dev

${comparisonRows.map((row) => `

${row.area}

${row.logicsrc}

${row.openspec}

`).join("")}

Compatibility Mode

logicsrc --openspec agentswarm --yolo \\
  --repo profullstack/logicsrc

--openspec enables OpenSpec.dev-compatible repo-local specs, proposals, tasks, and deltas where supported. openspec import and openspec export summarize those artifacts for LogicSRC workflows. --openspec-only restricts work to LogicSRC-published contracts.

Reference Implementations

These prove the standard, but they are not the LogicSRC identity.

${implementations.map((item) => `

${item.name}

${item.detail}

`).join("")}

Hire Us

$400/hour for accepted LogicSRC work using open infrastructure and open specs for AI agent systems.

Profullstack standards work

Open-spec AI agent implementation help

Hire us to turn agent ideas into portable LogicSRC specs, CLIs, SDKs, MCP resources, PWAs, APIs, and provider-neutral plugin workflows. We prioritize auditable contracts, repo-local artifacts, and integrations that can move between model providers and infrastructure.

$400 per hour

Billed against actual hours worked, invoiced after you approve them. Ten-hour minimum engagement; cancel any time with one week’s notice and pay only for hours already approved. See Terms.

${hireUsWork.map((item) => `

${item.name}

${item.detail}

`).join("")}

CoinPay hourly invoice

After we accept the project, we invoice approved hours at $400/hour through CoinPay without exposing merchant credentials to the browser.

COINPAY_ORG=profullstack
COINPAY_PRODUCT=logicsrc-hire-us
COINPAY_RATE_USD_PER_HOUR=400
COINPAY_BILLING=metered_hours
COINPAY_MINIMUM_HOURS=10
COINPAY_STATUS=pending_acceptance

Top-Level Pages

LogicSRC.com should expose stable project pages for docs, publishing, company context, and legal basics.

${pages.map((page) => `

/${page.id} · ${page.title}

${page.detail}

`).join("")}