Umbra

What the company appears to be: Umbra is a self-reported change-control plane for coding agents. The author states it is a system that governs agent authority in repositories by testing whether an agent can be trusted before allowing changes — using an "Agent Admission Test" with executable contracts, sandboxed checks, and signed receipts.

What changed: The project description shows a self-reported, unverified build of a governance layer for AI coding agents. It was submitted to the OpenAI 2026 hackathon and is described as a proof-of-concept or prototype built by one person (Binay Dalai) using tools like Codex, FastAPI, Next.js, and GPT-5.6.

Single most important open question: Is there any evidence of real-world usage, customer feedback, or traction beyond the author’s own account?

The description states that Umbra is a change-control plane for coding agents, designed to gate agent authority in repositories before allowing changes. It includes:

• An executable contract (.umbra/admission.yaml) that bounds change (allowed paths, diff budget, required checks), evaluated outside the model, fail-closed.
• A redaction mechanism that removes untrusted repository text before agent execution and restores it afterward to ensure signed diffs reflect only the agent’s real changes.
• Preflighted sandboxed checks, which run required validations in a fail-closed environment.
• An independent verifier that re-checks scope, secrets, and dependency bumps against CVEs.
• A server-side emergency brake and revocable authority levels (0 observe / 1 analyze / 2 branch-PR).
• Ed25519-signed receipts, verifiable against Umbra’s pinned public key.
• The system never merges PRs, only creates branches.
• Additional features include CVE scanning via OSV.dev, PR risk scoring, git-history root-cause analysis, and a ChatGPT GPT Action surface.

Inference: This is a governance layer that sits above existing agent tools (e.g., Codex, Devin) to enforce access control and trust boundaries before any code changes are made. It is not an AI review tool or dependency bot but rather a decision point for whether an agent should be allowed to act.

The author states that Umbra “sits one layer above” existing tools like AI review bots (CodeRabbit, Greptile), dependency bots (Dependabot, Snyk), and coding agents themselves (Codex, Devin). It does not replace these but instead makes the decision about whether a change is allowed.

Key claims:

• Umbra gates agent authority, unlike tools that comment or bump PRs.
• It adds an independent verifier that the patch-writer cannot bypass.
• It provides earned and revocable authority levels with signed receipts.
• The goal is to prove trust, not just review.

Inference: Umbra positions itself as a trust boundary tool for AI agents in code repositories, aiming to address risks like prompt injection, over-broad agent access, and lack of auditability. It is not a general-purpose AI assistant or a CI/CD tool — it’s a policy enforcement layer.

The description does not state specific customer segments or personas. However, the author implies that Umbra targets teams using AI coding agents in production environments where trust and control are critical.

Inference: Likely target customers include:

• Engineering teams deploying AI agents at scale.
• Organizations with strict security or compliance requirements.
• Teams managing large repositories with many contributors and agents.

Not evidenced: No explicit customer names, use cases, or ICP data.

The description does not mention any pricing model, monetization strategy, or business model. It is a self-reported hackathon project with no indication of revenue streams or commercial plans.

Inference: There is no evidence of a business model beyond the author’s own account.

The author reports:

• Built using FastAPI + async orchestrator, Next.js 15 + Tailwind.
• Uses Codex as primary engineer, writing the platform phase-by-phase.
• Runs Codex via Responses API (gpt-5.6-sol / terra / luna) for reasoning.
• Deployed on Google Cloud Run.
• Includes ~298 backend tests and offline fixtures for reproducibility.
• Implements Ed25519 signing, sandboxed execution, and redaction mechanisms.

Inference: The system is built with a focus on security, correctness, and auditability. It uses modern tools and techniques to enforce trust boundaries in code repositories.

The description states that this is a hackathon submission (OpenAI 2026) and was built by one person (Binay Dalai). There is no evidence of:

• Customers or users.
• Revenue or funding.
• Product adoption or usage metrics.
• Production deployment beyond the author’s own environment.

Inference: This is a proof-of-concept or prototype, not yet a mature product in use.

The description contrasts Umbra with:

• AI review bots (e.g., CodeRabbit, Greptile, Qodo) — which comment on changes.
• Dependency bots (e.g., Dependabot, Snyk) — which open bump PRs.
• Coding agents themselves (Codex, Devin) — which trust their own output.

It claims Umbra “decides whether a change is allowed at all”, rather than reviewing or bumping after the fact.

Inference: Umbra occupies a niche between agent execution and post-change review. It is positioned as a governance layer that sits above existing tools, not as a replacement for them.

• The project is self-reported only, with no independent verification.
• No evidence of real-world usage or customer feedback.
• The system is described as a hackathon prototype, not a commercial product.
• The author states that genuine Codex runs are founder-only and rate-limited, suggesting limited accessibility.
• There is no mention of scalability, performance, or integration with enterprise tools.

Inference: The project may be in early stages and lacks real-world validation. It could be a conceptual or experimental tool, not yet ready for production use.

1. What is the current status of Umbra? Is it being used in any production environments?
2. How does Umbra integrate with existing CI/CD pipelines or repository management systems?
3. Has there been any feedback from teams using AI agents in repositories that would benefit from this kind of control?
4. Are there plans to open up access beyond founder-only Codex runs?
5. What are the scalability and performance implications of running sandboxed checks at scale?
6. How does Umbra handle edge cases like large diffs, complex dependency trees, or multi-agent workflows?