BHCP

Inspiration

Programming languages still assume that a human is the primary author and maintainer of implementation code. That assumption becomes less useful as coding agents take on substantial implementation work. I wanted a program to say more than which steps to execute: it should state the outcome, the authority available to pursue it, the limits that must not be crossed, and the evidence required before anyone can call the work complete.

BHCP—Beyond Human-Centric Programming—explores that model. Humans retain control of intent, policy, and judgment. Machines can search for an implementation, but a plausible answer or self-reported success is not enough.

What it does

BHCP is a typed semantic compiler and governed-analysis foundation for agent-written software. A BHCP goal can declare typed inputs and outputs, requirements, guarantees, permitted and forbidden effects, limits, preferences, and verifier bindings.

The safe-Rust compiler parses that source, checks the supported semantic boundary, and lowers it into deterministic canonical AST and semantic IR artifacts encoded as CBOR. Equivalent programs can share one stable semantic identity even when their surface syntax and formatting differ, while presentation-sensitive artifacts retain a separate identity.

Policy composes monotonically. Ownership and effects are checked before IR is emitted. Unsupported constructs fail with stable diagnostics. Verification preserves the difference between satisfied, refuted, unresolved, and faulted results. The latest executable foundation also constructs mutually consistent obligation, capability, and state-analysis graphs for the governed reference program.

The Build Week trial uses a compact goal that requires a non-empty name, guarantees an exact greeting, permits filesystem reads, forbids network access, limits attempts, expresses a preference, and binds its semantic claims to a verifier. bhcp inspect makes that checked contract readable. Hashing a presentation-different version produces the same deterministic semantic identity.

How I built it

BHCP is implemented in safe Rust with a pinned Rust 1.97.1 toolchain. Deterministic CBOR and a CDDL wire schema provide the artifact boundary. The repository includes parsing and formatting, type and expression checking, effect and ownership analysis, policy and waiver handling, deterministic graph models, proof checking, verifier adapters, a CLI, conformance fixtures, and controlled coding-agent experiments.

The public repository was created during OpenAI Build Week. Focused pull requests, conformance artifacts, and 479 test functions record the work completed during the submission period. The submission candidate passes formatting, Clippy with warnings denied, partitioned tests, the release build, all 17 CDDL root fixtures, and the mutual-consistency audit for its obligation, capability, and state-analysis graphs.

How Codex and GPT-5.6 were used

GPT-5.6 was the model collaborator across every phase of the project: brainstorming the premise, refining the language and product direction, prototyping executable slices, structuring the wiki and issue roadmap, and implementing and testing the Rust compiler, semantic checks, conformance fixtures, and documentation.

Codex provided the repository-native environment for inspecting the normative contract, turning bounded issues into tests, implementing focused slices, running validation, reviewing contradictions across code, schemas, and documentation, and keeping unsupported claims out of the project narrative.

I remained responsible for the language's semantic boundaries, what counted as acceptance evidence, which claims were deferred, and whether each generated change matched the normative contract. Agent output was treated as a candidate requiring tests and independent review, not as proof of correctness.

Challenges

The largest challenge was scope discipline. A language for agentic software can quickly become a parser, planner, runtime, policy system, proof system, SDK, and workflow engine all at once. BHCP therefore separates the normative v0 contract from the executable slices that are actually demonstrated, and rejects unsupported behavior instead of erasing it.

Determinism was another challenge. Semantic meaning, source presentation, provenance, and packaged artifacts need different identity boundaries. Normalizing exact numeric values, policies, graph sets, profiles, and CBOR while retaining useful diagnostics required careful tests around both equivalence and meaningful change.

The evidence experiments were also instructive. Early model runs did not demonstrate a BHCP-over-prose advantage, and the repository preserves those negative results. That made the central lesson concrete: evidence needs to be part of the system precisely because a compelling story is not the same thing as a supported claim.

What I learned

Agentic programming needs a sharper separation between intent, authority, execution, and evidence. An agent should not gain authority merely because a plan mentions an operation, and a successful process exit should not automatically establish that a semantic obligation is true.

Human-readable syntax and machine-stable meaning do not have to be the same artifact. Deterministic semantic identity makes it possible to compare, cache, govern, and verify meaning without requiring every person or tool to use one surface notation.

Building with Codex also reinforced the project's thesis: agents can implement a large amount of carefully bounded work quickly, but only when the repository makes authority, tests, review, and evidence explicit.

What's next

The next steps are the remaining end-to-end execution graph, planner, runtime, evidence graph, public SDK, and complete reference-program pipeline. This submission is deliberately narrower: it demonstrates a working semantic compiler and governed-analysis boundary for goals, deterministic artifacts, policy, effects, ownership, graphs, and verification evidence without claiming that the full platform already exists.

Built With

• agentic-workflows
• cbor
• cddl
• command-line-interface
• compiler
• developer-tools
• github-actions
• gpt-5.6
• mise
• openai-codex
• policy-as-code
• rust
• static-analysis