Jentra platform architecture and validation

Executive conclusion

Jentra's central architecture is viable: independent agents can work in isolated Git-backed Worlds, remain aligned to shared canonical context, submit attributable results, undergo independent verification and compose accepted work without collapsing authorship, evidence or human authority into a single opaque agent session.

The assessment passed with documented boundaries. Live infrastructure testing established repository isolation, credential enforcement, revocation, event delivery and ordinary Git composition. Deterministic end-to-end scenarios established coordination, stale-context handling, independent assurance, consequential human decisions and final resolution. Clean-install testing established that the published self-hosted package can start independently.

Questions assessed

The programme evaluated whether Jentra preserves the properties needed for consequential human–agent collaboration:

1. Can parallel work remain isolated while sharing one baseline and one intended outcome?
2. Can credentials enforce World and capability boundaries rather than relying on prompt compliance?
3. Can a newly assigned agent reconstruct what happened, why it happened and what remains?
4. Can evidence, dissent and failed verification survive rework instead of being overwritten?
5. Can accepted work be composed through ordinary Git while conflicts remain explicit?
6. Can human-only decisions remain human-only across web, CLI, SDK and agent clients?
7. Can the same coordination model support non-code work when the runtime provides suitable tools?
8. Can admission and coordination scale independently from the cost and capacity of model execution?

System under test

Jentra is a coordination layer, not a model and not a replacement for Git. A Project holds durable work context. A Journey optionally represents one consequential goal. Participants, including people and agents, receive bounded Assignments. Worlds provide isolated workspaces. Contributions retain authorship and evidence. Verification is independent from authorship. Decisions record explicit human authority. Resolution composes accepted work without implying deployment.

The tested boundary included the control plane, Cloudflare-backed repository integration, Git composition, event handling, agent-facing contracts, the web/CLI/SDK projections and the experimental self-hosted package. Model intelligence itself was not treated as a Jentra capability.

Methodology

The report consolidates related evidence into one assessment rather than presenting each test layer as a separate report. Four complementary methods were used.

Live infrastructure validation

Disposable repositories, forks and scoped credentials were exercised against Cloudflare infrastructure. Concurrent pushes, cross-World access, read-only enforcement, revocation, history inspection, event delivery and cleanup were observed directly.

Deterministic domain scenarios

Ordered commands and events exercised coordination, dependencies, stale context, assurance, decisions, conflicts and resolution with repeatable assertions.

Client conformance

Web, CLI, SDK and adapter paths were checked against the same canonical state and authority rules. A harness could not gain domain authority merely by claiming a role.

Distribution validation

The signed self-hosted package was verified from a clean environment, built, started and checked through health and account-entry routes.

Tests deliberately separated mechanical facts from semantic conclusions. A clean Git operation, for example, was evidence of composition, not proof that a change was correct. A passing verification was evidence for acceptance, not permission to deploy.

Results

Infrastructure and Git

World A and World B began from the same commit and accepted overlapping concurrent pushes. Each retained its own content and history. Ordinary Git identified changed files and overlap; one independent change composed cleanly, while an intentional overlapping change produced an explicit conflict. This supports Jentra's decision to keep composition interoperable with local Git and common IDE workflows.

Continuity and alignment

Context was represented as versioned canonical state rather than as an unstructured chat transcript. New participants could recover intent, accepted facts, unresolved work and decision history. When a shared contract changed, impact was calculated per World: unaffected work continued, while affected work became stale and received a successor context manifest.

Verification and resolution

A deliberately defective contribution was assigned to an independent verifier as a read-only candidate. The verifier reproduced the contradiction and retained counterevidence. Rework created a linked successor rather than rewriting the failed history. Later composition preserved selected, excluded and reconciled contributions, then required final verification against the exact frozen candidate before resolving the Journey.

Non-code work

The coordination model does not require source code. It requires identifiable artifacts, evidence, authority and delivery boundaries. Marketing or research agents can therefore work through Jentra when their Worlds expose the relevant tools. Jentra coordinates and records that work; it does not invent access to advertising, analytics, browsing or publishing systems.

30 October release update

The public integration surface was exercised after the original assessment without changing its architectural conclusion.

• Agent access: the published MCP server exposed five canonical Jentra tools and completed an authenticated production context read against a live Journey. Structured state matched the Journey intent, status, event sequence and freshness information.
• Portable continuation: independent live Codex and pinned Harness2 paths cold-started from the same verified Journey Capsule, preserved its exact identifiers and authority boundary, and produced semantic and structured continuation receipts without a private briefing.
• Public packages: @jentra/contracts, @jentra/local-runner, @jentra/sdk and @jentra/cli are available at version 0.2.4 through short-lived npm trusted publishing; @jentra/mcp-server and the portable agent skill are available at version 0.1.0.
• Project collaboration: the current release includes source connections, delegated capability manifests, setup profiles, skill and MCP guidance, and private-import fail-closed behaviour when no approved credential resolver is configured.
• Self-hosting: the signed downloadable release is version 0.2.1-experimental for Local Docker or a user's own Cloudflare account.
• Focused regression: the repository gate passes 290 tests across 55 files, including handoff context, accepted-work continuation, stale alignment, runtime-host recovery, callback idempotency, embedded-credential rejection and private-memory isolation.

Public-page performance

A mobile Lighthouse laboratory run reported performance 85, accessibility 96, best practices 100 and SEO 100, with LCP 3.3 seconds, CLS 0.043 and no blocking time. A separate unthrottled Chrome DevTools trace measured LCP at 245 milliseconds, TTFB at 14 milliseconds and CLS at 0.01, and identified no material render-blocking or cache saving.

These are operator-side laboratory measurements, not independent field data. They do not replace separate-user usability evidence or performance measurements from independent locations.

Security and authority findings

• Infrastructure enforcement: repository-scoped credentials established practical isolation and read/write capability boundaries outside the prompt.
• Revocation: revoked test credentials were rejected immediately during validation.
• Independent review: authors could not fill their own assurance slot, and verifier access was limited to an exact read-only candidate.
• Human decisions: an agent-host claim of human approval was rejected; consequential responses required authenticated human authority.
• Separation of effects: verification, acceptance, integration, resolution, merge and deployment remained separate actions.
• Cleanup: disposable resources and credentials were removed after live testing; ordinary Worlds remain retain-by-default unless an authorised policy selects cleanup.

Cloudflare Artifacts remains an open-beta dependency and is therefore isolated behind an adapter. Jentra, rather than the repository provider, owns Participant-to-World-to-credential correlation and semantic policy.

How to interpret the scale result

The large-scale exercises validated control-plane admission, scheduling records and bounded artifact production using synthetic participants. They support a sharded coordination architecture in which many agents may share a World under bounded roles, rather than requiring one repository per agent.

They do not prove that one million AI models simultaneously reasoned, called tools or wrote production code. End-to-end agent capacity also depends on model-provider quotas, runtime hosts, repositories, external tools, network limits and cost. Jentra can coordinate more participants than a given model provider can execute at once; those are deliberately separate capacity questions.

Conclusion

The evidence supports Jentra's core proposition: people and agents can coordinate consequential work while keeping intent, isolation, evidence, dissent, authorship and authority legible. The architecture remains compatible with ordinary Git and local development, while adding a canonical coordination layer that agents, IDEs, CLIs and the web can share.

The appropriate claim is therefore precise: Jentra has passed its current platform architecture and validation programme with documented provider, scale and certification boundaries. Future reports should add new evidence without rewriting this record or turning one programme into artificial fragments.