Product · h|ve Platform

Apply engineering rigor to AI-native development.Get the most out of AI in your company.

Ship production-ready software, from spec-driven development to final deployment, the right way and on the first attempt. The h|ve Platform plugs into your existing codebase, the standards your team follows and the enterprise tooling you already use.

The layer

A common layer between people and technology.

h|ve sits between the team and the stack: it takes direction from people and makes the same rule hold for every agent, model and tool.

Humans / TeamStrategy · Direction · PrioritiesEngineering that extends people

  • Context

    Goals, architecture, policy and owner become an executable base.

  • Orchestration

    Agents, models and tools receive context and a sequence of work.

  • Integration

    Data, repositories, boards, CI and systems stay where they already are.

h|ve Platform

  • Guardrails

    Permissions, gates and policies travel with execution, not a checklist afterwards.

  • Observability

    Every action gets origin, decision, deviation, execution, cost and evidence.

  • Portability

    The stack can change without losing the layer that governs how it is used.

On top of the stack the company already has

  • LLMs
  • Agents
  • RAGs
  • Cloud and services
  • Repositories
  • Tests

Why h|ve matters

  • Without h|ve

    Connected tools, fragmented operation.

    Context gets lost between prompt, agent, PR, pipeline and approval. Governance tries to rebuild it afterwards.

  • With h|ve

    One common rule follows all the work.

    Context, authority, policy and evidence travel with the execution, whatever the tool.

  • Result

    More speed without giving up control.

    Context, authority, policy and evidence stay linked from the start to the result.

Capabilities

What the platform brings.

Six capabilities that act during execution, not in a review afterwards. Beside each one, the product screen where it shows up.

The capabilities

h|ve Map

Context

Goals, architecture, policy and owners become a base the work consults and respects.

Rules screen: who can do what in this company, at the Light, Standard and Strict levels
Modules

A platform that governs all your AI development.

Five modules around the same rule. Below, what each one does and what it asks of you.

h|ve Platform

  1. MapBusiness
  2. FlowBusiness and development
  3. JudgeDevelopment and data
  4. GuardDevelopment and governance
  5. LedgerAudit

  1. Context

    h|ve Map

    Business

    What it does
    Reads the documentation, the code and the decisions that already exist and distills all of it into a living model of your organization: capabilities, policies, owners and the rules the business actually follows. It is the semantic layer that gives AI the context it was missing, and it becomes the initial Flow configuration.
    What it asks of you
    The material you already have and a few hours from your leaders. Where documentation is missing, Map starts from reference models for your sector.

  2. Orchestration

    h|ve Flow

    Business and development

    What it does
    Carries each piece of work from intent to merge across nine stages, with a gate at every handoff that only advances against the right artifact. The board moves on its own by the state of continuous integration. The merge stays a human decision.
    What it asks of you
    That work goes through the board, and that each gate has its artifact. The architect override is always at hand, and always asks for a recorded reason.

  3. Drift analysis

    h|ve Judge

    Development and data

    What it does
    Compares the approved spec with what the pull request actually delivered and writes, on the PR itself, where the two drifted apart. Hardened against instructions hidden in untrusted content. Review starts already knowing where to look.
    What it asks of you
    An approved spec to compare against. With nothing agreed, there is no drift to point at.

  4. Editor barrier

    h|ve Guard

    Development and governance

    What it does
    Lives inside the editor. The instant the agent tries to write, it checks whether that file belongs to the card approved for that branch. If it does not, the write does not happen. Not a warning after the fact, a block before it exists.
    What it asks of you
    One install line and a card with an approved scope. It costs 1.5 seconds per check, with per-branch caching.

  5. Memory and trail

    h|ve Ledger

    Audit

    What it does
    Records every decision with author, authority and basis, in a history that only appends and never rewrites. Over time those decisions become the distilled memory of the company: an auditable trail that answers who decided, why and at what cost, and feeds business decisions.
    What it asks of you
    Nothing beyond working inside the flow. The trail forms on its own as decisions happen.

Native capabilities

  • Governed Context Layer

    Decisions and execution

  • FinOpsAI

    Cost and value at every level

  • BYOK

    Control of LLM keys

  • LGPD + Immutable trail

    Auditable evidence

Native governance. Without slowing delivery.

The flow

The same feature crossing the five layers.

Build faster, with higher quality and lower risk, with specs as your single source of truth, advanced context management and consistent enforcement of the standards your team sets. The h|ve Platform brings rigor, quality and consistency so your teams deliver at their best.

01 BUSINESSMap02 ARCHITECTUREFlow05 GOVERNANCEFlow · Guard · Judge03 DEVELOPMENTGuard · Judge04 DATALedgerMapCONTEXTBusiness intentThe request enters as a card, with an origin and an owner. Map distills the documentation you already have into a living model of the organization.INSPECTScapabilitiespoliciesdecisionsownersgaps by riskTHE MODEL BECOMES FLOW CONFIGURATIONFlowORCHESTRATIONThe configured methodNine stages, five human roles and two actors that are not people, in a single state machine on the server.INSPECTSstagesrolesgatestransitionsartifact at each gateno gateFLOWapproved specGUARDbranch scopeJUDGEAI statementFLOWfinalresultFLOWtwo signaturesFLOWreason for theoverrideFLOWhumancredentialwrite blockedIntent01 · backlogSpecification02 · specConstruction03 · devPull request04 · prIntegration05 · ciQuality and data06 · qa_dataArchitect07 · architectMerge08 · mainspec sent backdrift namedsignature deniedLedgerDISTILLED MEMORYThe eight transitions record themselvesAn append-only record. Nobody rewrites the past, and a refusal is kept with the actor and the rule that stopped it.INSPECTSactorauthoritybasisrefusaldivergencetoken costAI statementLedger hands the number back to the business

use the arrow keys to walk the eight steps

The white dot in the corner of a gate marks the transition only a human credential opens: approving a spec, failing quality, authorizing an override and merging into main. A dashed line is a return, and it carries the colour of the piece that sent the work back.

Product boundary

What h|ve will not do, and why.

A product is defined as much by what it refuses as by what it ships. These four are not missing, they are decided. They are races already won by others, and entering any of them means spending half a year to arrive last at a tie.

  • Context engine and semantic indexing

    Already owned in this market. Our memory is of decisions, not of code, and that distinction is a virtue as long as it does not try to be the other thing. The path is to integrate.

  • Parallel multi-agent orchestration

    Also already owned. h|ve runs on top of whatever orchestrates, not in its place.

  • AI code review

    Same. What this platform decides is who may, not whether it is right.

  • No-code rules engine

    Not before the rules settle. Building an editor to configure something that changes every week is building a tool for a moving target. Rules in code, versioned and with an effective period, already deliver the gate, the authority and the trail without any editor.

The reason for each is written down so nobody reopens them by mistake six months from now.

Governance

Every agent decision is observable, auditable and governable.

The machine proposes, a person decides, and whatever clears the gate is recorded. Open each item to see the control from the inside.

A person at the gate

Approving a spec, failing quality and merging into main are transitions only a human credential authorizes, verified at the source. An agent can propose the entire change, but it cannot sign off on it. The gate is a constant in the code, not a checkbox someone can clear on a Friday afternoon.

A capability nobody classified is born forbidden to the machine. The list of what only a person decides is not written by hand, it is derived from the transition table. When a new passage appears, it is born human as a consequence, not because someone remembered to add it. Letting the machine through takes an explicit act, and the list of what it may propose has two entries today: submitting a card to the spec queue and opening the pull request. In both, the work goes to a human for review.

And the override is not the machine in any code path: the function that would let it force a gate returns false in every case. It is a constant, not a setting.

Immutable audit trail

The trail is append-only: nothing is overwritten and nothing disappears, not even when a decision is reversed later. Every record keeps who decided, under what authority, on what basis and at what cost. That is the package you hand to an external auditor, instead of rebuilding the story from chat threads.

Privacy by design

h|ve does not index customer code. What travels is metadata, the spec and the pull request diff, enough to govern without copying your codebase. Processing region and retention window are set in the contract, and every sub-processor is declared up front rather than discovered later.

Access control

Roles and credentials keep people and agents apart, with permissions granted by function rather than by individual. Override belongs to the architect and always requires a written reason. The reason lands in the trail next to the author and the timestamp, so every broken rule has an owner and a justification.

Model independence

The platform does not lock you into one AI provider. The model comes in through a port, with an adapter per vendor behind it: switching is a configuration change, not a rewrite of the process, because the rules live in h|ve and not in one vendor prompt. The governance bar stays the same before and after the swap, and the trail records which model answered for each delivery. Today the operation runs with a primary provider and a secondary one, which takes over when the primary is unavailable.

Integrations

We integrate your current stack.

Agents work inside your code hosting, task tracking, chat, cloud and continuous integration tools.

No replacing. No lock-in. No interruption.

AI

Development

Collaboration

Claude
ChatGPT
Gemini
VS Code
Cursor
GitHub
MCP
Microsoft Teams
GitLab
Linear

h|ve Platform

h|ve Platform

AI

  • Claude
  • ChatGPT
  • Gemini

Development

  • VS Code
  • Cursor
  • GitHub
  • MCP

Collaboration

  • Microsoft Teams
  • GitLab
  • Linear
Frequently asked

The questions that come up before the conversation.

Does this replace my GitHub, my Jira or my editor?

No. h|ve governs on top of what you already use. The typical install removes no tool.

Do we need documented processes to start?

No. Half the cases start with no documentation. Map builds the first version of the model from reference frameworks for your sector and validates it with your leaders.

Will this slow my team down?

Barriers come in by choice, starting with one gate and two roles. Guard has a 1.5 second budget and lets the edit through if the service does not answer.

What is the AI not allowed to do?

To conclude on its own what requires human accountability. Approving a spec, failing quality and merging to the main branch require a person, with a person credential.

How much effort is the rollout?

Guard takes minutes. Flow in light mode takes less than a day. In Scan & Go, the first five phases add up to 14 working days with your leadership and selected teams.