PROJECTCORE · DEVELOPER DOCS

The control plane for human-and-agent systems.

ProjectCore gives developers the runtime, governance, memory, evaluation, ledger, and artifact rails required to build trustworthy AI systems in production.

Use ProjectCore when your product needs more than model output. Run agents with governed context, open bounded evaluation windows, promote only what should become part of the permanent record, delegate authority explicitly, halt unsafe behavior, and generate sealed artifacts over real decision history.

READ THE INTEGRATION GUIDE VIEW INTEGRATION GUIDE CONTACT US

WHAT IT IS

ProjectCore is the API-first control plane behind governed AI.

It is not a model provider, not a prompt wrapper, and not a chatbot product. ProjectCore is the backend layer that lets surfaces like ProjectBuild, ProjectLedger, and customer-owned apps run on shared rails for agent execution, memory, governance, evaluation, and immutable decision recording.

The point is not just to generate output. The point is to make output attributable, reviewable, correctable, and durable.

THE PRIMITIVES

Five primitives define the first integration surface.

Most teams start with five core methods:

run()

Execute one agent with governed context. Returns a reply, truth posture, and runtime metadata.

promote()

Commit a decision or note to the append-only ledger inside an open evaluation.

evaluate()

Open a bounded decision window so promote activity happens inside explicit scope.

delegate()

Create explicit authority delegation for bounded autonomous action.

halt()

Stop future runs for an agent when a rule, human override, or safety event requires it.

These are not abstract concepts. They are live API primitives documented in the integration guide and OpenAPI spec.

FIRST INTEGRATION PATH

The fastest working path is five calls.

For most teams, the cleanest first integration is:

create_evaluation()
run()
promote()
close_evaluation()
generate_artifact()

That gives you a full governed lifecycle from agent output to bounded decision window to immutable record to sealed Artifact 5 bundle.

POST /api/v1/evaluations
POST /api/v1/agents/run/simple
POST /api/v1/ledger/promote
POST /api/v1/evaluations/:id/close
POST /api/v1/artifacts/generate

SEE THE FULL LIFECYCLE WHAT DEVELOPERS NEED FIRST

The docs answer the questions engineers ask immediately.

How do I authenticate?
What parameters do I send?
What does the response look like?
What does an error look like?
What is required for autonomous action?
How does Artifact 5 sealing work?
Is there an SDK?

ProjectCore ships a full integration guide and machine-readable OpenAPI spec. The guide covers auth, request shapes, truth posture, authority delegation, evaluation lifecycle, promote constraints, artifact generation, and the Ledger UI payloads surfaces use to render governance and assessment views.

TRUST MODEL

Trust is enforced through runtime boundaries, not implied after the fact.

Truth posture

Agent replies are classified as known, inferred, or unknown so downstream systems can distinguish grounded answers from uncertain ones.

Authority

Human-led, human-in-the-loop, and agent-autonomous are declared explicitly at the moment of commitment.

Evaluation

Promote happens inside bounded decision windows. Closed evaluations reject further ledger writes.

Artifact 5

Closed evaluations can be sealed into deterministic artifact bundles with manifest hash, bundle hash, and signature metadata.

ProjectCore does not claim that model output is always correct. It provides the rails to make AI systems governable, attributable, inspectable, and durable.

TENANCY

Shared control plane. Isolated tenant boundaries.

ProjectCore currently provides logical tenant isolation at the project boundary. Tenant scope is derived server-side from authenticated context, all reads and writes are project-scoped, and cross-project access is rejected by default.

For standard deployments, this should be described as logical tenant isolation on shared infrastructure. For customers that require dedicated runtime or stronger deployment isolation, that should be offered as a higher-isolation deployment posture rather than implied as the default shared-service model.

AUTH

Bearer auth first. Roles enforced per route.

ProjectCore supports bearer authentication using managed API keys, legacy bearer token flows where supported, and Firebase JWTs. Route-level roles determine who can run agents, create keys, create delegations, or access ops-only paths.

For localhost development, a dev bypass can exist in development-only environments. It is not part of the production integration contract.

SDK + REFERENCE

Use the docs landing page first. Use OpenAPI when you are implementing.

ProjectCore currently provides:

Full Integration Guide
OpenAPI spec
Minimal TypeScript helper in-repo

ProjectCore does not yet claim a full generated public SDK.

OPEN THE GUIDE VIEW INTEGRATION GUIDE

Build on governed rails before the workflow is too important to rebuild.

If your team is moving from prompt experiments into production systems, ProjectCore gives you the backend primitives most teams eventually discover they need: runtime, memory, governance, evaluation, ledger, artifact sealing, and audit trails.

If you want to build your own surface on top of Core, start with the guide. If you want help structuring the integration, talk to us.

READ THE INTEGRATION GUIDE VIEW INTEGRATION GUIDE TALK TO US