PAUHU COMPILER | FOR HEAVY AI CODERS

Stop spending AI tokens on repeatable code work.

Pauhu Compiler is the MCP layer your AI coding agent calls when supported routine code work should be composed, cited and measured instead of guessed.

Keep your current AI coding workflow. Move repeatable work off the token meter. Composed, not guessed.

Buy & test on your repo See how it works

279 EUR/mo Month to month Cancel anytime No repo upload

mcp.pauhu.dev
> agent: read a csv and sum the second column
✓ pauhu: operation resolved from cited corpus
✓ code composed, off the model token meter for this operation
→ model: intent, context and review
→ receipt: sources, boundaries, tokens and energy

0 EUR model token cost

On the composed operation.

No repo upload

Your repository is never uploaded.

Receipts per call

Sources, boundaries, tokens and energy per composed call.

Same AI coding flow. Composed code out.

Pauhu runs through MCP between your local coding workflow and a hosted compiler. Your repository is never uploaded. Only task-sized context leaves your machine.

Your AI coding flow stays the same

Use your current AI coding tool and repo workflow.

Pauhu builds a bounded context

Pauhu selects only task-relevant files, schemas, standards and verified source material.

Pauhu returns cited code and a receipt

Every call returns composed output, source references, boundaries and receipt data.

Your model focuses on higher-value work

The model stays focused on intent, architecture, edge cases and review.

What Pauhu Compiler does

Composes cited code from verified sources.
Builds from bounded context, not the full repository.
Returns a receipt for every composed call.
Reports sources, boundaries, operation status, tokens avoided and energy data.

What Pauhu Compiler does not do

It does not replace your AI coding agent.
It does not upload your repository.
It does not train on your repository or bounded context.
It does not run code, install packages, edit files or take actions on your machine.

Ready to move repeatable code work off the token meter?

Test Pauhu Compiler on your own repo with your current AI coding tool. No repo upload. Month to month. Cancel anytime.

Buy & test on your repo

HOW IT WORKS

Keep your AI coding workflow. Move repeatable code work onto a cited, measured compiler layer.

Pauhu Compiler is the MCP layer your AI coding agent calls when a task should be composed from verified sources instead of guessed by the model. Your agent keeps the flow. Pauhu handles the bounded, repeatable layer and returns code, citations and a receipt for every supported call.

The flow

Your AI coding agent stays in charge of intent, context and review. Pauhu Compiler handles the bounded, repeatable layer.

Ask

The developer asks the current AI coding agent to complete a real coding task.

Call

The agent calls Pauhu Compiler through MCP when the task fits a supported repeatable operation.

Bound

Pauhu works with bounded input: selected files, schemas, standards, symbols or task context.

Compose

Pauhu composes code from verified sources and explicit context.

Return

The agent receives code, citations, gaps if any and a receipt for the call.

What crosses the wire

Only task-sized bounded context required for the supported compiler call crosses the wire: selected files, schemas, standards, documentation, symbols, conventions or task-specific snippets.

The full repository, git history, dependency folders, build output, secrets and unrelated files do not cross the wire.

Where Pauhu helps most

Schema-based code generation
API client and mapping code from published interfaces
Validation logic from explicit rules
Test scaffolding from existing project style
Standards-based boilerplate and adapters

Where the model stays in charge

Use your AI coding agent for exploratory design, architectural judgement, ambiguous requirements, creative refactoring and developer review.

Add Pauhu Compiler to your AI coding client in two minutes.

Pauhu Compiler is a remote MCP server at https://mcp.pauhu.dev/mcp. Add it with the API key issued at checkout. No local install. No extra proxy. Your repository is not uploaded. Only bounded context crosses the wire.

Quick start

The fastest way is to ask your agentic AI coding client to add Pauhu as a remote MCP server.

Add a remote MCP server named "pauhu" at https://mcp.pauhu.dev/mcp using HTTP streamable transport, with the header: Authorization: Bearer YOUR_KEY Replace YOUR_KEY with the API key from my Pauhu checkout. Then list the pauhu tools to confirm the connection.

Claude Code

claude mcp add --transport http pauhu https://mcp.pauhu.dev/mcp \ --header "Authorization: Bearer <YOUR_KEY>"

VS Code Copilot

// .vscode/mcp.json { "servers": { "pauhu": { "type": "http", "url": "https://mcp.pauhu.dev/mcp", "headers": { "Authorization": "Bearer ${input:pauhu-key}" } } } }

Cursor

// .cursor/mcp.json { "mcpServers": { "pauhu": { "url": "https://mcp.pauhu.dev/mcp", "headers": { "Authorization": "Bearer ${env:PAUHU_KEY}" } } } }

Codex

# ~/.codex/config.toml [mcp_servers.pauhu] url = "https://mcp.pauhu.dev/mcp" bearer_token_env_var = "PAUHU_MCP_KEY"

Works with your MCP client

Pauhu Compiler works anywhere your coding client can call a remote MCP server: Claude Code, Claude Desktop, ChatGPT, VS Code Copilot, Cursor, Codex, Grok, Windsurf, Cline, Continue, Zed, JetBrains, Gemini CLI and Mistral — plus any other client that speaks MCP.

Remote MCP endpoint

Use Pauhu as a remote MCP server at https://mcp.pauhu.dev/mcp. Keep your API key out of the repository. After setup, list the Pauhu tools in your client to confirm the connection before sending task-specific context.

Safe by design

Composes from bounded context, not from your repository.
Returns a receipt showing sources, boundaries, operation status, tokens avoided and energy data.
Does not upload your repo, train on it, run code or take local actions.

Use cases

Standard code operations
Documented API calls
Bounded AI context
Schema and spec-based code

Let the receipts prove the value.

Pauhu Compiler starts at 279 EUR per licence per month. Run supported tasks on your own repo, inspect receipts showing sources, boundaries and model tokens avoided, then expand only if the data supports it. No repo upload. No annual lock. Cancel anytime.

Pauhu Compiler

279 EUR

/ licence / month

Month to month. Cancel anytime. No annual lock. No repo upload.

Buy & test on your repo See FAQ

Prove it on your repo

AI coding costs vary by model, task, context and session length. Start with one licence, run real tasks and inspect the receipts. If Pauhu does not show enough value against 279 EUR/month, cancel.

Volume pricing

Every additional licence lowers the per-licence price. Start small, measure usage, then expand only if the receipt data supports it.

Licences	Price / licence / month	Total / month
1	279 EUR	279 EUR
5	227 EUR	1,135 EUR
10	208 EUR	2,080 EUR
25	185 EUR	4,625 EUR
50	169 EUR	8,450 EUR
100	155 EUR	15,500 EUR
500	126 EUR	63,000 EUR
1,000	116 EUR	116,000 EUR

What is included

Hosted MCP endpoint access
Supported composed operations
Receipts for composed calls
Month-to-month billing

What is not included

Your external AI coding tool subscription
External LLM provider costs outside Pauhu
Unsupported tasks handled by your agent
Custom enterprise reviews unless separately agreed

WHY PAUHU

Turn repeatable AI coding work into receipt-backed compiler calls.

AI coding agents are useful for intent, architecture and review. Pauhu Compiler handles the repeatable layer: bounded input, cited operations, deterministic output and a receipt showing what was composed, what sources were used and what moved off the model token meter.

Buy & test on your repo See how the receipt works

The problem with using models for repeatable work

Open-ended models are valuable, but not every coding task should be another variable generation.

Variable cost

Longer sessions, larger context and repeated tool calls make AI coding spend harder to predict.

Variable output

Repeatable code work should not depend on changing model behavior or plausible-looking guesses.

Weak audit trail

If a buyer cannot see what was used, what crossed the wire and what was composed, the result is hard to review.

What Pauhu changes

Pauhu turns supported repeatable work into bounded compiler operations with explicit failure modes.

Compiler operation, not model guess

The same bounded input and operation version return the same cited output.
Your AI coding agent keeps handling intent, architecture, edge cases and review.
Retrieval, verification and the content path are deterministic, not embedding-based guessing.

Gap instead of bluff

Pauhu emits an answer only when independent deterministic checks agree.
If the checks do not agree, the intended failure mode is a gap or no answer.
The goal is to prevent confident-but-wrong output from becoming accepted output.

Inspectable by default

Your repository is not uploaded.
Only task-sized bounded context crosses the wire.
The receipt shows sources, boundaries, operation status, tokens avoided and energy data.

Why this matters by stakeholder

Pauhu is built for the buying committee, not only the developer who connects the MCP endpoint.

Engineering

Less repeatable glue work through the model. More focus on intent, architecture and review.

Security

Task-sized bounded context. No repo upload. No local actions.

Finance / Ops

Supported composition work moves off the model token meter and becomes measurable per call.

Procurement

Month-to-month start, one licence, inspectable receipts and no annual lock.

When Pauhu earns its place

Use Pauhu when the work is repeatable, source-grounded and worth measuring.

Use Pauhu for

Schema-based code
Documented API calls
Validators
Mappings
Adapters
Tests
Standards-based boilerplate

Do not use Pauhu for

Open-ended architecture
Ambiguous product decisions
Creative refactoring without a stable target
Tasks without source material
Replacing senior engineering review

Prove it on your repo.

Buy one licence, run supported tasks and inspect the receipts before adding more seats.

Buy & test on your repo

TRUST

Made to be reviewed, not just trusted.

One place for procurement, security and legal: what crosses the wire, where processing happens, who the sub-processors are, what Pauhu can access and what the receipts prove.

Trust boundary

Hand Pauhu the work, not the keys.

Your repo stays local

Your repository is not uploaded. Your coding client holds the repository. Only the bounded context a supported request needs crosses to Pauhu.

Scoped, rotatable access

Access uses an API key you control, sent as a Bearer header over TLS. Keep it confidential. Keys can be rotated on request or after a suspected leak.

No local actions

Pauhu does not run code, install packages, edit files or take actions on your machine. Your client and developer workflow stay in control.

What crosses the wire

The boundary is intentionally narrow.

What Pauhu receives

Only task-sized bounded context required for the supported compiler call: selected files or snippets, schemas, standards, documentation, symbols, project conventions and the operation request.

What does not cross

The full repository
Git history
Dependency folders and build output
.env files, secrets, credentials, private keys, tokens and certificates
Unrelated files outside the task-sized context

EU processing and sub-processors

Composition happens in the European Union. The DPA is the authoritative source for sub-processors, transfers and retention terms.

EU composition

Composition runs in the European Union through Hetzner Online GmbH in Helsinki, Finland.

Payment processing

Stripe, Inc. handles payment processing in the USA using SCCs / EU-US DPF as disclosed in the DPA. Your code and repository are never transferred to a payment processor.

Compiler layer, not a profiling model

Pauhu is designed as a deterministic compiler layer, not as a learning model or developer-profiling system.

Not an AI system

Pauhu composes code from cited operations and published standards. It does not learn from, profile or make automated decisions about users. Legal classification should be read from the current Imprint, DPA and Terms.

Auditable by design

The same bounded input and operation version return the same cited output. Each composed call returns a receipt showing sources, boundaries, operation status, model tokens avoided for the composed operation and energy data.

Verification and failure mode

The trust promise is not that Pauhu is magic. It is that supported outputs are checked, bounded and allowed to fail safely.

Independent checks before commit

Pauhu does not commit an answer just because it looks plausible. It emits an answer only when independent deterministic checks agree.

Wrong or conflicting sources

If bounded input conflicts with required rules, cited sources, provenance or operation-specific constraints, Pauhu should return a gap instead of composing an answer.

Defect-by-defect improvement

Pauhu does not improve by training on customer code. Wrong answers, missed gaps or failed checks are measured, classified and closed by updating deterministic operations, rules, mappings, checks or tests.

Honest current status

Pauhu does not claim perfect detection of every hidden bug in a user repository or every incorrect upstream source. The architecture is built to eliminate confident-but-wrong failures, but remaining cases are closed defect by defect. Closing, not claimed closed.

No third-party scripts

The site is kept narrow for privacy and review.

The pauhu.dev site loads only from pauhu.dev. No analytics SaaS, no third-party trackers and no external embeds. Cookie and storage use is limited to strictly necessary preferences and the payment provider.

Documents

The legal set, in one place. GDPR bases, retention periods and user rights are in the Privacy Policy. To request or sign the DPA, email hello@pauhu.ai.

Policies

Privacy Policy — statutory register description Data Processing Addendum — Article 28 Terms of Service Acceptable Use Policy Licence Cancellation & Refund Policy Imprint

Good to know

SOC 2 and ISO 27001 attestations are not published today.
No published uptime SLA today.
DPA and security questionnaire available by request: hello@pauhu.ai.
Pauhu AI Ltd · Business ID 3477255-1 · Helsinki, Finland.

Review the boundary before rollout.

Review Trust first, then buy one licence and let the receipts prove whether Pauhu earns a wider rollout.

See Pricing Read FAQ

FAQ

Questions buyers ask before connecting Pauhu to a real repo.

Clear answers for Engineering, Security, Finance/Ops, Procurement and Legal. No repo upload. No annual lock. No claim that every AI cost disappears. Every supported composed call returns a receipt.

Buy & test on your repo Review the trust boundary

Buying decision

For teams deciding whether Pauhu is worth testing on a real repository.

What problem is Pauhu Compiler meant to solve?

Pauhu Compiler is for teams already using AI coding tools heavily. It moves supported repeatable code work away from open-ended model generation and onto a compiler layer that composes from bounded input, cited operations and verified sources.

Is Pauhu another AI coding agent?

No. Your AI coding agent stays responsible for intent, context, architecture, edge cases and review. Pauhu is the MCP compiler layer the agent can call when a task fits supported repeatable code work.

Who should buy Pauhu first?

Start with one developer or team that already feels token cost, context size, repeated boilerplate or hallucinated glue-code pain. The first purchase should prove whether Pauhu earns its place on real supported tasks in your own workflow.

What does a successful first test look like?

Connect Pauhu as a remote MCP server, run several small supported tasks on a real repo, inspect the outputs and receipts, then compare the value against 279 EUR/month. A good test proves useful composed output, clear source grounding, visible boundaries and measurable token shift for supported operations.

When is Pauhu not the right purchase?

Pauhu is not the right fit if you only use AI coding occasionally, mainly need open-ended architecture or product judgement, cannot test supported operation types on a real repo, or require a custom deployment before using any hosted MCP endpoint.

Pricing, value and cancellation

The buying model is designed to be measurable before expansion.

What does Pauhu cost?

Pauhu Compiler starts at 279 EUR per licence per month. It is month to month, with no annual lock. Start with one licence and expand only if the receipt data supports it.

Is there a free trial?

No. Pauhu Compiler does not offer a free trial by default. The default buying path is: buy one licence, test Pauhu on your own repo, inspect the receipts, and cancel if it does not prove enough value for your workflow.

How do I cancel or get a refund?

You can cancel anytime through the self-service billing portal linked from your account, or by emailing hello@pauhu.ai. After cancellation, access continues until the end of the period you have already paid for, and the subscription does not renew.

Because the subscription is month to month and access continues until the end of the paid period, partial months are not generally refunded. Charges made in error will be refunded. If you subscribe as an EU/EEA consumer, you may have a statutory 14-day withdrawal right, subject to the conditions in the Cancellation & Refund Policy.

Does Pauhu remove all AI token costs?

No. Pauhu does not claim that every AI cost disappears. Your AI coding agent and external LLM provider may still use tokens for intent, context, review and unsupported tasks. Pauhu moves supported composed operations off the model token meter for that operation.

Can you prove savings before we buy?

Not honestly with a universal average. AI coding usage varies by model, task, context size, tool calls and workflow. The proof mechanism is a real test on your repo. Each receipt shows what Pauhu composed and what model tokens were avoided for the supported composed operation.

What happens if Pauhu does not prove useful enough?

Cancel. The product is month to month. The intended buying path is to start small, measure real usage and expand only when the receipts justify it.

What is included in the licence?

The licence includes access to the hosted MCP endpoint, supported composed operations from cited operations and verified source material, receipts for composed calls, and month-to-month billing.

What is not included?

Your external AI coding tool subscription, external LLM provider costs outside Pauhu, unsupported work handled by your own AI coding agent, and custom enterprise security reviews or private deployment unless separately agreed.

Usage, limits and fair use

Pauhu is built for real development use, with limits that protect availability for all customers.

Are there rate limits?

Yes. The subscription is for ordinary individual or team development use. Pauhu may apply fair-use and rate-limit rules to protect service availability. Sustained automated abuse, attempts to overload the service, resell access, extract the corpus or bypass access controls may lead to throttling or suspension.

How Pauhu works

For technical buyers who need to understand the actual boundary and flow.

How does Pauhu fit into the AI coding workflow?

Pauhu is added as a remote MCP server. Your current AI coding client can call Pauhu when a task fits a supported repeatable operation. The developer keeps the repo workflow, and the AI coding agent stays in charge of intent and review.

What is a bounded context?

A bounded context is the task-sized material needed for a supported compiler call: selected files or snippets, schemas, standards, documentation, symbols, conventions or explicit task inputs. It is not the full repository.

How does Pauhu compare to context-trimming tools?

Context-trimming tools reduce the amount of repository context sent to an LLM by selecting, summarising or filtering files. Pauhu Compiler does something different: it composes supported operations deterministically from bounded input, cited operations and verified sources.

That means Pauhu is not just “less context to the model.” It is a compiler layer for repeatable work. Only task-sized bounded context crosses the wire, and unsupported tasks return a gap instead of a guessed answer.

Why does Pauhu cost no tokens?

Pauhu’s supported composition operation does not call a model or perform GPU inference for that composed operation. It composes deterministically from cited operations and published sources, so that supported composition work is off the model token meter.

This does not mean your whole AI coding workflow costs zero tokens. Your own AI coding assistant or LLM provider may still use tokens for intent, context, review, replies or unsupported tasks. Pauhu’s receipt shows what moved off the model token meter for the deterministic call made through Pauhu.

What is an MCP server, and is Pauhu one?

A Model Context Protocol, or MCP, server is a standard way for an AI coding client to call an external tool. Pauhu Compiler is a remote MCP server at mcp.pauhu.dev. Your coding client connects to Pauhu with an API key, then calls Pauhu for supported deterministic, cited code composition.

Your current AI coding assistant stays responsible for intent, context and review. Pauhu acts as the compiler layer behind that workflow.

Does the same request always return the same result?

The precise version is: the same bounded input and operation version return the same cited output. That is the control difference between a supported compiler operation and an open-ended model guess.

What happens if Pauhu cannot compose the task?

Pauhu reports a gap instead of pretending. Your AI coding agent can then handle the task as it does today.

Does Pauhu replace developer review?

No. Pauhu returns cited output and a receipt. Developers still review, test and decide what to merge.

Repository, security and data governance

The main security promise is a narrow boundary: hand Pauhu the work, not the keys.

Does Pauhu upload my repository?

No. Your repository is not uploaded. Pauhu receives only the task-sized bounded context required for a supported compiler call.

What crosses the wire?

Only the bounded context needed for the call, such as selected files or snippets, schemas, standards, documentation, symbols, project conventions and the operation request.

What never crosses the wire?

The full repository
Git history
Dependency folders and build output
.env files, secrets, credentials, private keys, tokens and certificates
Unrelated files outside the task-sized context

Does Pauhu train on my repository or bounded context?

No. Pauhu does not use your repository or bounded context to train a model.

Does Pauhu run code, install packages or edit files?

No. Pauhu does not run code, install packages, edit files or take local actions on your machine. Your client and developer workflow stay in control.

How should we handle the API key?

Access uses an API key over TLS. Keep the key out of the repository, store it in a secure client input or environment variable, and rotate it on request or after a suspected leak.

Where does processing happen?

Composition runs in the European Union. The DPA is the authoritative source for sub-processors, transfers and retention terms.

Receipts and auditability

The receipt is the proof mechanism behind the product claim.

What does a Pauhu receipt show?

A receipt should show the task, bounded context type, repository upload status, sources used, excluded material, operation status, gaps if any, model tokens avoided for the composed operation, energy data when available and timestamp.

Why does the receipt matter to a buyer?

It turns a compiler call into something inspectable. A buyer can see what was requested, what source material was used, what crossed the wire, what was composed and what happened if Pauhu could not compose the task.

Does the receipt prove the code is production-ready?

No. The receipt proves the call boundary and source grounding for the composed operation. Developers still review, test and own the final code.

Can Security or Procurement review Pauhu before expansion?

Yes. The Trust page, DPA, security questionnaire and receipts are the review path. Current limits should be stated clearly: SOC 2 and ISO 27001 attestations are not published today, and there is no published uptime SLA today.

Error handling and improvement loop

How Pauhu prevents confident-but-wrong output from becoming accepted output.

How does Pauhu stop process errors from passing through?

Pauhu does not commit an answer just because it looks plausible. The model handles only intent and composition. Retrieval, verification and the content path are deterministic. Pauhu emits an answer only when independent deterministic checks agree.

If the checks do not agree, the intended failure mode is a gap or no answer — not a confident wrong answer.

What if the source code or source material is wrong?

Pauhu does not blindly treat every input as truth. The engine checks bounded input against deterministic rules, cited sources, provenance and operation-specific constraints. If the source material conflicts with required checks, Pauhu returns a gap instead of composing an answer.

Pauhu does not claim perfect detection of every hidden bug in a user repository or every incorrect upstream source. If all provided inputs are wrong in the same way and no deterministic check exposes the issue, developer review and tests still matter. That is why every output is bounded, cited and reviewable.

How does Pauhu learn from mistakes?

Pauhu does not learn by training a black-box model on customer code. It improves through a controlled defect loop. When a wrong answer, missed gap or failed check is found, the defect is measured, classified and closed by updating the deterministic operation, rule, source mapping, validation check or test case.

The corrected operation can then be versioned and re-run reproducibly. The honest status is: the architecture is built to eliminate confident-but-wrong failures, but remaining cases are being closed defect by defect. Closing, not claimed closed.

Coverage, correctness and limits

Pauhu should be used where the work is repeatable, source-grounded and worth measuring.

What tasks are a good fit for Pauhu?

Use Pauhu for supported repeatable work such as schema-based code, documented API calls, validators, mappings, adapters, tests, standards-based boilerplate and repeatable code assembly from verified source material.

What tasks are not a good fit?

Do not use Pauhu for open-ended architecture, ambiguous product decisions, creative refactoring without a stable target, tasks without source material, or replacing senior engineering review.

Can Pauhu invent APIs, packages or missing source material?

For composed operations, output must trace to cited operations, verified sources and published documentation. If the source is missing, the correct behavior is to return a gap instead of a plausible-looking invented API or package.

Does Pauhu guarantee correctness?

No. Pauhu provides cited, traceable output for supported operations. Correctness still depends on developer review, tests, project constraints and the final merge decision.

What is the safest way to start?

Start with one small, inspectable task. Ask the client to use Pauhu only with the relevant schema, API definition, selected files or existing test style. Do not send the full repository. Review the receipt before using Pauhu on larger tasks.

Setup and integration

Pauhu is designed to sit behind your existing MCP-capable coding client.

Which clients can call Pauhu?

Pauhu Compiler works anywhere your coding client can call a remote MCP server: Claude Code, Claude Desktop, ChatGPT, VS Code Copilot, Cursor, Codex, Grok, Windsurf, Cline, Continue, Zed, JetBrains, Gemini CLI and Mistral — plus any other client that speaks MCP.

What is the remote MCP endpoint?

Use Pauhu as a remote MCP server at https://mcp.pauhu.dev/mcp. Authenticate with the API key issued at checkout.

Is there a local install?

No local install is required for Pauhu itself. Add the hosted remote MCP endpoint in your coding client and confirm the Pauhu tools before sending task-specific context.

What should we do after setup?

List the Pauhu tools in your client to confirm the connection. Then run one small, bounded task and inspect the returned code, citations and receipt.

Does Pauhu lock us into one editor or agent?

No. Pauhu works through MCP as a compiler layer behind the workflow. Your team can keep the current AI coding client and switch tools later if the new tool can call a remote MCP server.

Compliance, legal and procurement

Use the controlling documents for legal terms. The website should not be treated as legal advice.

Is Pauhu GDPR-ready?

Review the DPA, Privacy Policy and sub-processor list for processing, retention, deletion and transfer details. The DPA is the authoritative document for processor terms.

Is Pauhu an AI system under the EU AI Act?

Pauhu is designed as a deterministic compiler layer, not as a learning model or developer-profiling system. Any legal classification should be read from the current Imprint, DPA and Terms, not from marketing copy.

Are SOC 2, ISO 27001 or an uptime SLA published?

No. SOC 2 and ISO 27001 attestations are not published today, and there is no published uptime SLA today. A DPA and security questionnaire are available by request.

Can public sector or procurement teams buy by invoice?

Pay by card for a fast start. Public sector teams that need a purchase order can use Stripe Invoicing at the same pricing curve where available.

Who owns the composed code?

You own the composed code and may use, modify and distribute it, subject to the licences of any cited sources. Pauhu retains all rights in its corpus, composition engine, service and server-side components.

Composed programs may include provenance markers such as cited source references. You may remove those markers for production use, but you remain responsible for complying with the licences of any upstream sources referenced by the output.

Do you use any third-party scripts or trackers?

No advertising or analytics trackers are used. The site uses no external or third-party scripts for tracking. Cookie and storage use is limited to strictly necessary preferences and the payment provider.

Pauhu does not store card numbers. Payment data is handled by Stripe; Pauhu receives a customer reference and subscription status.

Is self-hosting available?

Not by default. Enterprise or self-hosted deployment should be handled separately if offered.

Still evaluating the boundary?

Review Trust first, then buy one licence and let the receipts prove whether Pauhu earns a wider rollout.

Review Trust See Pricing

BLOG

The antitoken notebook.

Short, sourced notes on AI coding cost, security and compiler-based control.

Articles

Buyer education for teams evaluating whether repeatable AI coding work should become cited, measured compiler calls.

Why AI coding bills jumped in 2026

Usage-based billing makes AI coding spend variable. Here is the fixed-layer response.

Slopsquatting is a real AI coding risk

AI-generated packages can be fake. Supported compiler operations must trace to cited sources.

How to make AI coding spend predictable without capping engineers

Do not slow down heavy users. Move repeatable composition to a fixed-cost layer.

What a Pauhu receipt proves

A receipt turns a compiler call into something a buyer can inspect, compare and measure.

When not to use Pauhu Compiler

The fastest way to build trust is to say clearly where Pauhu does not belong.

ARTICLE

Why AI coding bills jumped in 2026

Buyer question: Why did AI coding stop feeling like a fixed subscription?

AI coding spend has moved from simple seat pricing toward usage-sensitive pricing. The reason is straightforward: agentic coding uses models for longer sessions, larger context windows, more generated output and repeated tool calls.

GitHub measures Copilot organization and enterprise usage in AI credits. The interaction consumes input tokens, output tokens and cached tokens, and the cost depends on the model and the number of tokens consumed. Cursor states the same pattern through included model usage and on-demand usage. Claude Code also exposes the practical limit: heavy users may need higher tiers, usage credits or pay-as-you-go API usage.

That is the new cost shape. Heavy AI coding is no longer only a licence question. It is a variable workload question.

The wrong response is to cap engineers

Caps make the bill safer by making the workflow worse. They interrupt the people doing the work. They also push teams toward hidden workarounds: smaller prompts, weaker models, local hacks or untracked API keys.

The better response is to separate the work

Not every coding task needs another open-ended model generation. Some work is repeatable: standard operations, documented API calls, schema-based validators, mappings, adapters and tests. Pauhu Compiler moves supported repeatable composition to a fixed-cost compiler layer.

The AI coding agent stays where it is strongest: intent, architecture, edge cases and review. Pauhu handles supported work that should be composed, cited and measured instead of guessed.

What changes with Pauhu

Your repository is not uploaded. Your current AI coding workflow stays in place. Only task-sized bounded context crosses the wire for supported calls. Each composed operation returns a receipt showing sources, boundaries, operation status and model tokens avoided for that operation.

This does not make every AI cost vanish. Your own AI coding agent may still use tokens for intent, context and review. Pauhu changes the variable cost profile of supported repeatable code work.

GitHub Docs: usage-based billing for organizations and enterprises Cursor pricing: usage-based pricing explanation Claude Help Center: Claude Code usage limits and billing options Claude Help Center: Max plan usage tiers and limits

Buy & test on your repo

ARTICLE

Slopsquatting is a real AI coding risk

Buyer question: What happens when an AI assistant invents a dependency that looks real?

AI-generated code can contain package names that do not exist. That is not just a quality issue. It can become a supply-chain issue when an attacker registers the invented package name and fills it with malicious code.

Research on package hallucinations found that code-generating LLMs hallucinated packages at average rates of at least 5.2 percent for commercial models and 21.7 percent for open-source models. A 2026 replication found lower rates across newer frontier models, roughly 4.62 to 6.10 percent, but concluded that the threat remains.

The point is not that every AI-generated dependency is dangerous. The point is that plausible-looking code is not the same as verified code.

Why models do this

A model predicts the next token from context. A package name can look statistically plausible without existing in a registry. The model can be confident and wrong at the same time.

What Pauhu changes

Pauhu Compiler is not a licence to trust every generated dependency. It is narrower and safer: in supported composed operations, Pauhu does not invent APIs or packages. Output must trace to cited operations, verified sources and published documentation. Unsupported tasks return a gap instead of a confident guess.

That distinction matters. A general AI coding agent may propose something plausible. A compiler layer can be required to produce only what its operation library and cited sources support.

The buyer takeaway

Use the AI coding agent for intent, architecture and review. Use Pauhu for supported repeatable code work that should trace to sources. If the source is missing, the correct output is not a hallucinated package. It is a gap.

Spracklen et al.: package hallucinations by code-generating LLMs Churilov: 2026 frontier-model package hallucination replication

ARTICLE

How to make AI coding spend predictable without capping engineers

Buyer question: How do we control AI coding spend without slowing down the team?

Usage-based AI coding spend creates a FinOps problem inside engineering. The harder the team works, the more variable the bill can become. Dashboards and budgets help, but they do not change the shape of the workload.

FinOps is about maximizing technology value, enabling timely data-driven decisions and creating financial accountability across engineering, finance and business. AI coding spend now belongs in that conversation.

The bad options

You can leave usage uncapped and accept invoice volatility. You can cap usage and interrupt heavy users. You can push engineers to cheaper models and accept weaker results. None of those options fixes the structural issue.

The structural fix

Separate open-ended reasoning from repeatable composition. Keep the AI coding agent for intent, architecture, edge cases and review. Move supported repeatable work to Pauhu Compiler: standard operations, documented API calls, schema-based code, mappings, adapters and tests.

That creates a cost line that can be bought, tested and scaled. Pauhu starts with one seat. If it proves useful on a real repo, add seats. If it does not, cancel.

What the receipt does

A budget dashboard shows spend after the fact. A Pauhu receipt shows the call: sources used, boundaries, operation status and model tokens avoided for the composed operation. That gives the buyer evidence, not just a claim.

What this does not include

Pauhu does not remove the cost of your AI coding agent, model provider or external LLM calls outside Pauhu. It moves supported composed operations off the model token meter and makes that work inspectable.

FinOps Foundation: What is FinOps? GitHub Docs: AI credits and usage-based billing Cursor pricing: included model usage and on-demand usage

ARTICLE

What a Pauhu receipt proves

Buyer question: How do we know what Pauhu did?

A receipt is the difference between a product claim and an inspectable call. If Pauhu composes code, the buyer should be able to see what happened.

The receipt does not need to be long. It needs to answer five questions: what was requested, what sources were used, what crossed the wire, what was composed, and what happened when Pauhu could not compose the task.

A good receipt shows

Task: the requested operation.
Context boundary: selected files, schemas, docs, symbols or conventions used for the call.
Repository boundary: confirmation that the repository was not uploaded.
Sources: cited operations, verified source material, published standards or documentation used for the output.
Operation status: composed, gap, fallback or error.
Cost data: model tokens avoided for the composed operation and energy data when instrumented.

Example receipt format

call_id: [PLACEHOLDER_CALL_ID] repo_upload: no context_type: bounded task: compose UserProfile validation and tests sources_used: - openapi.yaml - schemas/user_profile.yaml - tests/test_user_profile.py excluded: - full repository - git history - .env - secrets - dependency folders operation_status: composed model_tokens_avoided_for_composed_operation: [PLACEHOLDER] energy_data: [PLACEHOLDER] timestamp: [PLACEHOLDER]

Why this matters

MCP gives AI applications a standardized way to connect with external tools, context and capabilities. That makes the tool layer important. Pauhu’s promise is not that the agent becomes magic. It is that supported compiler calls become bounded, cited and reviewable.

Model Context Protocol specification Model Context Protocol tools specification

ARTICLE

When not to use Pauhu Compiler

Buyer question: Where are the limits?

The fastest way to trust an engineering tool is to know where it does not belong. Pauhu Compiler is not a general coding brain. It is a compiler layer for supported, repeatable code work.

Use Pauhu when

The task is repeatable.
The output can be grounded in source material.
The API, schema, standard or convention is known.
The result should be cited, measured and repeatable.
The buyer wants a receipt for what was used and what moved off the model token meter.

Do not use Pauhu when

The task is open-ended architecture.
The decision is a product judgment, not a compiler operation.
The source material is missing or ambiguous.
The task requires creative refactoring without a stable target.
The team expects Pauhu to replace senior engineering review.

What happens outside coverage

If Pauhu cannot compose the task, it should report a gap. Your AI coding agent can then handle the work as it does today.

The point

Use AI for intent, architecture and review. Use Pauhu for repeatable code work that should be cited, measured and composed instead of guessed.

That boundary is the product.

Pauhu product positioning source Model Context Protocol specification