Engineering,
on demand.
An autonomous software-engineering platform. Submit a brief. Ship working code. For any codebase, in any domain.
One agent. Or five. Decided per task.
Most agent platforms have fixed roles — Planner, Coder, Reviewer — running in the same shape for every task. HissAI's planner reads your brief and emits a fresh topology each time. A bug fix gets one agent. A multi-feature build gets five working in parallel. No hard-coded shape.
GET /version endpoint to api/main.py that returns the package version. Don't break /health.Five rings around every agent.
The agent loop is the smallest, most-constrained component. Around it: input validation, pre-execution gates, plan-time validation, runtime isolation, post-execution checks. Every action passes through every ring. Authorization, branch policy, budget caps, sandbox isolation, test gates — all enforced before anything touches your repo.
Nothing happens you can't see.
Every LLM call traced. Every tool call logged. Cost attributed per task, per agent, per role. Built on a durable execution kernel — any workflow can be replayed deterministically from its journal. For debugging, for compliance, for trust.
task/001-add-version. Tests passed. Diff reviewed by verifier sub-agent.From brief to pull request.
Every task moves through the same gates. Nothing skipped, nothing rushed.
Durable
Tasks survive crashes, deploys, and day-long human pauses. Built on a replay-based runtime — never a coin flip.
Isolated
Each sub-agent runs in a fresh microVM sandbox. No host filesystem. Network egress allowlist only.
Observable
Every call traced. Every cost attributed. Every workflow replayable. Audit trail by default.
Not every agent platform is built the same.
Three differences matter most.
| Capability | HissAI | Typical agent platforms |
|---|---|---|
| Agent topology | Decided dynamically per task | Fixed roles, same shape every time |
| Human-in-the-loop | Fallback — humans called only when stuck | Gate — humans approve every step |
| Audit trail | Every call, full deterministic replay | Logs, no replay |
| Isolation | Fresh microVM per sub-agent | Shared workspace, container-level |
| Domain assumptions | Zero — works on any codebase | Often opinionated about stack |
| Branch + merge policy | Configurable per project, policy-enforced | Convention, not enforced |
Private beta now. Open soon.
Working with a small group of partners first. Generally available once the feedback loop closes.
A handful of teams running real engineering work through HissAI. Domain-agnostic. Every task auditable end-to-end.
Self-serve onboarding, BYO-keys, enterprise SSO, and on-prem sandbox deployment for compliance-sensitive teams.
Engineering velocity, on demand.
We open beta access in waves. If your team has a backlog you can't get to — let's talk.
Get in touch →Brief in.
PR out.
Three layers do the work — planning, execution, verification — each with its own safety envelope.
Hiss-Orchestrator decides the shape.
The orchestrator is a single Claude call with one job: read the brief, read the project context, emit a typed plan. How many sub-agents. What roles. What runs sequentially, what runs in parallel. The plan is JSON — validated against a schema before any agent runs.
Same orchestrator, completely different plans, because the input changed.
One microVM per sub-agent.
Each agent runs in a fresh Firecracker microVM. Its workspace is a git worktree of the target repo. Its tools come from a Cedar policy scoped to its role — investigator gets read-only, implementer gets write, verifier gets the browser. Network egress is allowlisted. Token budgets capped per call.
When the sub-agent finishes, the sandbox is destroyed. No state leaks. No cross-contamination.
firecracker microVM · 2 vCPU · 1 GiB RAM ·
ephemeral filesystem · egress allowlist: api.anthropic.com, api.github.com
read_file✓
write_file (within workspace only)✓
run_tests✗
git_push (workflow-only)✗
shell(rm -rf) (blocked by Cedar)
Tests pass. Diff scanned. PR opened.
Before any change reaches your repo: pre-commit hooks run (lint, format, type-check). The test suite must pass. A separate verification pass reviews the diff for suspicious patterns — large deletes, sensitive paths, lockfile bypass. Only then does HissAI open a pull request. Auto-merge is opt-in per project, off by default.
task/001-add-version
Every dollar accounted for.
Hiss-Orchestrator runs on the strongest model. Sub-agents use the cheapest model that handles their role. Background scoring uses a Haiku-class model that costs a rounding error. Every task has a budget envelope — enforced before each call.
Five rings.
Zero shortcuts.
The agent loop is the smallest, most-constrained piece. Production HissAI wraps it in concentric rings of governance — and every call passes every ring.
Every gate, named.
Input validation
- Template schema check
- Completeness score ≥ threshold
- Interview mode triggered if ambiguous
- Required fields enforced
Pre-execution gates
- Authorization (Cedar policy)
- Repo allowlist per submitter
- Branch policy: base, naming, protected exclusions
- USD budget envelope, time budget
Plan-time validation
- Plan JSON validated against schema
- Max agent count enforced
- Budget split sums within envelope
- Forbidden operations rejected pre-execution
Runtime isolation
- Firecracker microVM per sub-agent
- Tool allowlist per role (Cedar)
- Network egress allowlist only
- Per-call token budget
Post-execution checks
- Pre-commit hooks (lint, format, types)
- Test suite must pass
- Diff scanner for suspicious patterns
- PR opened; humans merge
Audit + recovery
- Every LLM and tool call traced
- Cost attributed per task/agent/role
- Deterministic replay from journal
- request_help → human inbox, workflow pauses
Your repo. Your rules.
HissAI never pushes to your protected branches. Each task creates a
deterministic feature branch — task/<id>-<slug> —
off a base branch you configure per project. Force pushes forbidden.
Main and release branches blocked at the policy layer.
Nothing silent. Nothing irreversible.
Every call
LLM calls, tool calls, sub-agent spawns. Hierarchical trace tree per task. Clickable from PR to the prompt that produced it.
Per dollar
Cost attributed by task, agent, role. Budgets enforced before each call. No surprises in your bill.
Deterministic
Any workflow can be replayed exactly from its journal. For debugging, compliance evidence, or regression testing.
Engineered for
production.
The same primitives a serious engineering team would assemble — if they had the time. Durable execution. Cryptographic identity. Typed policy. Real observability.
Best-in-class, replaceable.
Every layer shares an open protocol — MCP, OpenTelemetry, CloudEvents, OpenAPI. Glue stays thin. Components stay swappable.
Durable execution
Restate — replay-based runtime. Tasks survive crashes, deploys, and day-long human pauses.
Agent runtime
Claude Agent SDK on the latest Claude models. Bounded loops, structured outputs, typed contracts.
Tool protocol
Model Context Protocol. One open contract for every tool and every service HissAI talks to.
Sandbox
Firecracker microVM per sub-agent. Sub-second cold start. Network egress allowlist.
State + memory
PostgreSQL with pgvector. Entities, semantic recall, audit — one source of truth.
Policy + identity
Cedar for fine-grained authorization. SPIFFE for per-agent cryptographic identity.
Tracing + evals
Langfuse. Every prompt, every tool call, every model decision — observable end-to-end.
Code understanding
Tree-sitter AST + semantic search. Real comprehension of your codebase, not pattern matching.
Verification
Playwright in-sandbox for UI verification. Test suites run before any claim of success.
No microservices we don't need.
HissAI runs on one durable kernel, one Postgres, one sandbox provider, one tracing pipeline. Cheap to operate, easy to reason about. Complexity is added only when measured pain demands it — never speculatively.
Why this
exists.
Every engineering team carries a backlog of small, well-scoped work that keeps slipping. Fixes, tweaks, ports, integrations, tests. Important enough to want done. Not important enough to staff.
HissAI runs that work. Auditably, reversibly, on any codebase. Built so the team stays on the hard problems and the long tail finally moves.
Engineering velocity that's auditable, reversible, and bounded — so any team, on any codebase, can clear the work they've been deferring.
Built, then sold.
Core
Hiss-Orchestrator, sub-agent runner, durable execution, sandbox, tracing — all wired and running.
Customers
Working with a small group of partners running real engineering work end-to-end.
Open
Self-serve onboarding, enterprise SSO, on-prem deploy for compliance-sensitive teams.
Be one of the first.
The first ten teams shape how HissAI grows. We listen as much as we ship.
Get in touch →Let's talk.
HissAI is in private beta. Tell us about your team and what's on the backlog. We'll be in touch when a slot opens.
We answer every email a human writes. Usually within a day.
Privacy Policy
Last updated: May 30, 2026
HissAI is in private beta. This document describes, in plain language, what we collect from beta partners, how we use it, and what we never do.
What we collect
- Account info — name, work email, team/company.
- Task briefs and outputs — what you ask HissAI to build, and what HissAI produced. Used to run the service and to debug failures.
- Repo access tokens — scoped GitHub credentials you grant per project. Stored encrypted, revocable at any time.
- Usage metadata — task counts, LLM cost, latency, error rates.
What we do with it
- Run your tasks — read your repo, write the code, open the PR.
- Improve the product — failure modes, success rates, latency improvements (in aggregate).
- Bill you accurately (in beta this is free; the same data powers billing later).
What we don't do
- We don't train our models on your code. Period.
- We don't read your code outside of running your tasks.
- We don't share your data with third parties unless legally compelled (in which case we tell you when allowed).
Deleting your data
Email privacy@hissme.online and we'll remove every record we hold within seven days.
Contact
Questions: privacy@hissme.online. Humans answer.
Terms of Service
Last updated: May 30, 2026
Using HissAI
HissAI is provided to beta partners under a written agreement. By accepting an invitation you agree to these terms and any project-specific agreement we exchange.
What HissAI is, and isn't
HissAI is an autonomous engineering tool that proposes changes to your codebases via pull requests. It is not a substitute for human review. Every change we open is reviewed by your team before merge unless you explicitly enable auto-merge per project.
Your code
Your code is yours. We hold a limited licence only to clone, run, and write to it within the scope of running your tasks. We don't train models on your code. We don't redistribute it.
What you agree not to do
- Use HissAI to access or modify systems you don't have authorization for.
- Use HissAI to circumvent security controls in third-party software.
- Resell or sublicense HissAI access without written permission.
Limitation of liability
The service is provided "as is" during beta. To the extent permitted by law, HissAI is not liable for indirect, incidental, or consequential damages arising from your use. We've engineered for safety, but we cannot guarantee an AI-generated change is the right one for every codebase.
Contact
Questions: hello@hissme.online.