In production today
The productivity floor
is about to move.
Anneal makes all your AI act as one workspace — right inside the tools you already use: Claude Code, Codex, Gemini, VS Code. Your context follows you everywhere, always compounding. No new app to open.
AI proliferation created
a new coordination problem.
Your team now has access to a dozen AI tools. Each one powerful in isolation. None of them aware of the others. The result: more context switching, more copy-pasting, more time managing AI than using it.
Before Anneal
- Ten AI tabs, zero shared context
- Rewriting the same prompts, every session
- No memory of what worked yesterday
- Team insights trapped in personal chat histories
- AI output that knows nothing about your actual work
With Anneal
- One workspace, all your AI capabilities
- Context persists — session to session, person to person
- Workflows that compound over time
- Team intelligence, not just individual prompts
- An AI layer that actually knows what you're working on
"The floor just moved."
The teams that win from here aren't the ones who use AI the most — they're the ones whose AI workspace compounds. Every interaction builds context. Every workflow gets sharper. Anneal is how that happens.
One workspace.
Every capability.
Anneal isn't a place you go. It's the layer underneath the AI tools you already use — making them context-aware, connected, and consistent, without changing how you work. The tab-switching, context-copy-pasting workflow most teams call "using AI" just... stops.
Unified across your tools
One context layer for every AI surface you work in — Claude Code, Codex, Gemini, VS Code. Same memory, everywhere, no starting from scratch.
Context that travels
Anneal remembers what matters — across sessions, across tools, across teammates. The AI that knows your work, not just your last message.
Structured workflows, not just chat
Turn AI into a repeatable production workflow. Templates, stages, outputs — built to ship, not to explore.
Team-ready from day one
Share context, prompts, and workflows across your whole team. What works for one person automatically benefits everyone.
Compounding intelligence
Every interaction makes the next one better. Anneal builds a model of how you work — and gets sharper the longer you use it.
The AI layer your team was waiting for
Not another tool to manage. The substrate that ties every AI tool you already use into one coherent, context-aware whole.
This site was built by the
machine it runs on.
Anneal runs on grāmatr. So did building this website — 200+ turns of real human-and-AI work. Here's what happens on every single one. The prompts are blacked out; the machinery is the point.
You prompt
▓▓▓▓▓▓▓▓ ▓▓▓▓▓ ▓▓▓▓▓▓▓▓▓▓
grāmatr reads what the request actually needs — before the model sees it.
Classify
The request is understood and routed. Simple asks stay cheap; hard ones get depth.
Assemble the packet
Only the context this task needs — the right files, the one prior decision that contradicts it, your conventions. Not a document dump.
Enforce your rules
"inject the standards bar" · "only change what's asked" · "no ‘done’ without evidence"
Your directives, applied on every agent, every turn — automatically.
Dispatch & gate
The right specialist agent runs — and its output has to clear the quality bar before it ships.
One real turn from this build — unredacted
The directives baked into every turn — the rules that actually shape the code:
- Inject the full standards bar up front — lint, coverage minimums, SRP, DRY — so it's right on the first pass, not the fifth.
- Only change what was requested — no unrequested refactors, no scope creep.
- Every “done” cites real evidence — a passing test, a diff, a log line. The absence of errors is not success.
- DRY and SRP are proven, not claimed — reviewed after writing, refactored the moment a violation shows up.
- Plan, then stop for approval — the model doesn’t start coding uninvited.
- Never commit a secret or credential. Not once.
Nothing hidden — the actual packet that fires every turn ↓
gmtr.intelligence.contract — injected before the model responds
You are enhanced by the grāmatr intelligence layer. Every prompt is
pre-classified and a contextual block is injected before you respond.
TIER 1 (session-stable): identity · always-on directives · hard gates
TIER 2 (per prompt): classification · dynamic directives · required
actions · memory refs · suggested agents
## Always-on behavioral directives
- Never commit credentials, API keys, or secrets to version control
- Never rubber-stamp verification — every PASS needs specific evidence
- Only change what was requested — do not refactor unrequested code
- When asked to create a plan, present it and STOP — do not execute
- Query memory (search_semantic) in OBSERVE — HARD GATE
- Call classification_feedback with the original prompt in LEARN — HARD GATE
- Call save_reflection in LEARN — HARD GATE
## The packet, per turn
classification effort_level · intent_type · confidence
directives.hard_gates non-negotiable — override everything
directives.required_actions BLOCKING — complete before responding
process.phase_template OBSERVE → THINK → PLAN → BUILD → VERIFY → LEARN
quality_gate_config criteria set before BUILD; each PASS needs evidence
memory.context pre-loaded user + project state; use directly
## Phases (in order, do not combine)
OBSERVE consume memory first
THINK reverse-engineer what the prompt is actually asking
PLAN write the acceptance criteria (quality gates) up front
BUILD implement
VERIFY mark each criterion PASS/FAIL with a specific evidence artifact
LEARN classification_feedback + save_reflection (trains the classifier)
This is the real thing — the same contract that governed all 200+ turns
of this build. No slideware.200+ turns · 34 files shipped · ~20 specialist agents dispatched · every turn classified, gated, and logged. Prompts redacted. Real build.
And it’s not just this website. The output is public — not a claim you take on faith:
Not a survey. Not an estimate. A public, GitHub-auditable record — go check it yourself. That step-change, the week the layer came online, is what the productivity floor moving actually looks like.
Memory remembers.
Anneal directs.
A briefing bound for a global consultancy — the kind that normally eats weeks and a small team. From a single prompt, Anneal didn't just recall the relevant context. It read what the work required, reverse-engineered the intent, set the bar the output had to clear, and told the frontier model how to do the work — then produced it, first-pass.
A memory layer hands the model a pile of notes and hopes. Anneal directs the model — which is why the output cleared the full bar on the first pass, and why brute force couldn't. Not compression, not recall. Direction. That's the floor moving. Engagement anonymized.
How Anneal compounds.
Five stages. One continuous loop. The longer you run it, the faster it spins — and the further ahead you get.
Start with a task. Anneal surfaces relevant context automatically.
Prior work, team patterns, and relevant context — delivered before you ask.
AI output that's grounded in your actual work, not generic training data.
Iterate in place. Every edit teaches Anneal what good looks like for you.
Output goes out. Context stays in — ready to make the next task faster.
Individual leveling
Anneal builds a personal productivity layer — your prompts, your patterns, your output style — that gets better the more you use it.
Team leveling
What one person learns, everyone benefits from. Shared workflows, shared context, shared intelligence — without the coordination overhead.
Compounding returns
Day 30 isn't the same as Day 1. Anneal accumulates context the way a great analyst does — and applies it automatically.
Works with the AI you already use.
Anneal isn't another model — it's the substrate that makes every model better. Use Claude, GPT-4, Gemini, or any other foundation model with one consistent, context-aware layer underneath.
Switch models mid-workflow. Compare outputs side-by-side. Your context stays consistent regardless of which model you use.
Reliability you don't think about.
Anneal runs on grāmatr — the AI infrastructure platform built for teams that take reliability seriously. Sub-100ms context delivery. 99.9% SLA. Fail-open by design, so your work never stops.
It stays out of your way and never goes down. Anneal is what you actually use.
Learn about grāmatr →Skip the build. License Anneal.
Want Anneal for your whole organization, but don't want to build an AI layer from scratch? You don't have to. Anneal is in production today — license it and deploy in weeks, not quarters. Your people get the workspace that directs and enforces your directives on every agent, with the audit trail already built in.
A design-partner media agency is already running Anneal in production today — alongside a bespoke app built on the same grāmatr platform.
The floor is moving.
Get on the right side of it.
Anneal is in production today. Early access is limited — we're onboarding teams who want to shape what the AI workspace looks like.
Or email us directly at hello@gramatr.com. No sales process. Just a conversation.