Your AI Now Navigates Your Perspective — v2026.07.04 (July 4, 2026)

The headline: your AI no longer swallows your whole compiled perspective on every read. It navigates — loading a compact, steering-grain map of what your organization knows, then expanding only the regions your task needs. Seven weeks of work reached production in one release around that change: digest + expand navigation, self-updating knowledge, live cost accounting, and the evaluation battery that proved it all before it shipped.

Highlights

Digest + expand: navigation replaces the embedded snapshot

Every consumer of your perspective — your AI loading context, extraction, validation, citation, introspection, and deployed agents — now reads through a collapsed digest: a map of your knowledge at steering grain, with every deeper node one expand away.1 Nothing is hidden and nothing is dumped; the recognized path is just faster, and per-call context drops by an order of magnitude.

What you’ll notice: perspective loads are focused — a map plus full depth on exactly what you asked about — and a new expand tool resolves any compressed pointer to full quotes and provenance. (Reconnect your MCP integration once to pick up the new tool.)

The map updates itself as you save

Navigation only works if the map is current — so saving a memory now automatically refreshes exactly the affected regions of the digest, nothing else, and commits the refresh alongside your knowledge, versioned in your own repository. Untouched regions stay valid indefinitely; the map is complete at steady state, not progressively catching up.

What you’ll notice: minutes after you save something, loading your perspective reflects it — including brand-new themes the save introduced.

The evaluation battery, and why this release earned its way out

We didn’t merge on green checkmarks. A pre-registered evaluation replayed real historical memories through the old production pipeline and the new one at identical repository states, and measured the difference mechanically.2 The headline: the old pipeline anchored quotes to exact character positions 0% of the time; the new one, 100% — with every quote byte-exact against the source. Grounding you can slice a file and check.

What you’ll notice: citations that point at exactly the right text, every time. The first save through the new production pipeline landed its quote anchor byte-for-byte.

Costs are now first-class

Every knowledge operation now records what it actually cost — model calls, cache hits, dollars — queryable per save.3 Extraction traffic routes through a caching relay that cuts warm-path token costs by roughly an order of magnitude.

What you’ll notice: nothing, unless you ask — and then the answer is exact instead of estimated.

Also arriving in this release

Everything below shipped to our development line over the past seven weeks and reaches you today (the three releases beneath this entry document that line):

  • See your own usage: ask your AI for your aswritten usage — spend, limits, and per-operation history, straight from your account.
  • Safer writes everywhere: protected branches get automatic fallback branches and review PRs instead of failed saves; brand-new branches just work.
  • Sharing that stays yours: perspective shares are live references to your repo (pin them for a frozen snapshot); import shares are email-gated.
  • You’re always your own reviewer: every memory you save enrolls you on its review, whichever way your account signs in.

Fixes & Improvements

  • Saving a memory reliably enrolls you as its reviewer regardless of how your account signs in — the review flow is the quality gate, and it no longer silently skips anyone.
  • Interrupted connections recover transparently after deploys; no more stuck sessions after a server restart.
  • A budget-exhausted account now gets a polite warning instead of (in one edge case) a hard lockout.
  • Saves to brand-new branches, protected-branch fallbacks, and memory IDs derived from headings all hardened with regression tests.

The release history is now public

This changelog now runs back to February with retroactive release breaks — Pilot Hardening (v2026.05.18), Billing & Usage (v2026.06.09), Digest Navigation (v2026.06.25), Reliability Wave (v2026.07.01) — each tagged in the repository and documented below.

Reliability Wave — v2026.07.01 (July 1, 2026)

Development-line release — this work reached production with v2026.07.04 above.

This release is the cleanup after last week’s read-layer cutover. Once the new navigation path was live, a run of latent gaps that the old path had never exercised surfaced as real failures — and this window fixes them one by one until saving a memory is solid end to end again.

Highlights

Saving a memory works end to end again

The cutover exposed a chain of quiet gaps — a misrouted internal address, unset model configuration, a missing version reference — each of which could break a save. Every one is now fixed and defaulted, on both staging and production paths. Saving a memory, including on a brand-new branch, is verified green across the full test suite.

What you’ll notice: remember is reliable again, including the first save to a fresh branch — a case that used to error.

Saving direct is first-class

Writing a memory straight to your working branch is now the primary path, and opening a pull request is the fallback we fall back to only when a branch is protected. That’s a deliberate product choice: the common cases — a solo user with no branching model, or a team member on a working branch — shouldn’t pay the friction of a review flow they didn’t ask for.4

What you’ll notice: saves are direct and immediate wherever they can be, and gracefully route through a pull request only where your repository requires one.

Faster reads, by design

The perspective response is now ordered as a stable skeleton first, with the part that changes per request appended last. That ordering lets a prompt cache hold the stable front of the response across calls — a structural speedup, not a tuning knob.5

What you’ll notice: repeated reads get cheaper and quicker as the stable part is reused.

Extraction retries instead of failing you

When an extraction comes back truncated or empty, the system now recognizes that as a transient hiccup and retries on a cheaper fallback model — within a shared, bounded retry budget — instead of failing your save outright.

What you’ll notice: fewer saves lost to a momentary model glitch, with no runaway cost.

A signal worth noting

An outside advisor and prospective design partner — a fellow founder building adjacent infrastructure — independently arrived at nearly the same architecture the product is built on, down to the same core query approach, chosen unprompted. It’s the strongest peer validation of the core technical bets we’ve had to date.6

Fixes & Improvements

  • Diagnosed a suspected staging out-of-memory issue down to deploy churn — in-flight extractions cut short by rapid redeploys — rather than a genuine memory leak; added a lever to keep it in check.
  • Cleaned up a recurring divergence between local and shared development branches.
  • Landing-page and docs polish: site-wide orphan control, static pages ported to the current style, and a tag-driven posts section replacing a hardcoded link.
  • Extraction now computes text-position offsets precisely, normalizing typography and decoding escapes so citation anchors land on the right text.

This entry is a historical backfill, published as part of the changelog rebuild.

Footnotes

Digest Navigation — v2026.06.25 (June 25, 2026)

Development-line release — this work reached production with v2026.07.04 above.

This release rebuilt how the product reads your knowledge. Instead of stuffing the entire compiled perspective into every prompt, every part of the system now navigates a compact map and pulls in only the region it needs. It’s both a big reliability fix and the architecture bet the product now runs on.

Highlights

Every reader now navigates instead of memorizing

Extraction, validation, citation, introspection, and the deployed customer-facing agent no longer receive the whole compiled snapshot embedded in their prompt. Each one steers a compact map of your perspective to the right region, then expands only what it needs.7

What you’ll notice: faster, steadier reads — and the intermittent extraction failures that came from an oversized prompt are gone. The bloated embed was the documented root cause; navigation takes it off that path entirely.

The map guides; it never gates

The compact map is a recognition aid over your full, lossless knowledge — a way to find the right material fast, never a replacement for it. Any richer or novel reading is always one expansion away, so compression for navigation never quietly flattens what you actually said.8

What you’ll notice: the summary you see is a doorway, not a ceiling. Nothing is hidden behind it.

A note on how this shipped

We’re telling this one straight because it’s a good story about our own discipline. We shipped the new read layer, then pulled it back the same day when our own pre-registered evaluation bar hadn’t actually been cleared — the mechanism worked in a smoke test, but the full before-and-after comparison that proves quality was never run in full.9 We re-landed it hardened nine days later, with the complete evaluation battery run and the earlier gaps closed.

What you’ll notice: we hold shipping to the same bar we tell customers to hold their AI to. If the evidence isn’t in, it doesn’t ship — even when it “seems” to work.

Also in this release

  • Per-team local development so contributors can each run a full isolated stack.
  • A cleaner internal process — we retired our old external project tool and moved everything to the repository as the single source of truth.10
  • A refreshed strategy document and a rebuilt content pipeline.

Fixes & Improvements

  • The expand tool, previously unusable in some configurations, now works and fails loudly when it can’t find a repository.
  • Map parsing hardened against multi-line and special-character content; any unparseable entry is dropped rather than breaking the read.
  • Read-path budgets calibrated so large perspectives stay within safe limits.
  • Pagination never clips — full richness is always reachable.
  • Honest placeholders for not-yet-expanded regions, with accurate wording about what’s known and what’s absent.

This entry is a historical backfill, published as part of the changelog rebuild.

Footnotes

Billing & Usage — v2026.06.09 (June 9, 2026)

Development-line release — this work reached production with v2026.07.04 above.

This release turned the raw activity record from last time into a usage product you can actually ask for: a usage tool for account owners, a cohort-aware view of how a team really adopts the product, and a hard safety guard so a tool call can never touch a repository you didn’t name.

Highlights

Ask your AI how your team is using the product

Account billing contacts can now pull a usage summary directly through the tool surface — no dashboard, no console. Ask for it in conversation and it comes back as structured activity.

What you’ll notice: the same conversational surface you already use for everything else now answers “how are we doing?” too.

Usage that shows the shape, not just the total

The usage view is built per-user and per-day rather than as one aggregate number. That’s deliberate: aggregates inherit the heaviest user’s shape and hide whether a durable core of habitual users is forming or whether early-trial users are quietly dropping off. This view surfaces both.11

What you’ll notice: you can see who’s sticking, who’s churning, and how reading and writing split across your team over time — the signal a single total erases.

Nothing writes to a repository you didn’t name

Three layered guards now sit behind every write: an explicit repository that resolves to a different one is refused outright, connections can be scoped read-only, and every save echoes back the exact target it wrote to. This closes a real incident where a save intended for one repository landed in another.

What you’ll notice: writes are safe by construction. If your AI is about to write somewhere you didn’t intend, it stops instead.

Positioning that firmed up

Two framings settled this month. First, the plan tiers aren’t separate markets — Expert, Team, and Organization are one use case at different scale, and the only variable is how many people write to and read from the perspective.12 Second, the organizing frame for what the product is: steering a decision process. Whether it’s an architecture board, an investment committee, or a partners’ meeting, the product is always the memory the steering runs on — never the loop that does the steering.13

Fixes & Improvements

  • Error notifications now fire at real boundaries instead of on every step of a long internal chain — and a transient hiccup in one validation step no longer fails a whole run.
  • The activity record now times a tool call by when it actually finished, not when it started streaming.
  • Extraction reports “no extractable claims” honestly instead of hard-failing, and distinguishes that from a genuine model failure.
  • Loading a perspective against a nonexistent version now fails loudly instead of silently returning nothing.
  • Language-model calls retry on transient failure, with a shorter wait and no arbitrary output cap.
  • The deploy pipeline moved to prebuilt images with the running commit surfaced at a health endpoint, so you can always tell exactly what’s deployed.
  • Distinct shares over the same knowledge but different versions no longer collide into one record.

This entry is a historical backfill, published as part of the changelog rebuild.

Footnotes

Pilot Hardening — v2026.05.18 (May 18, 2026)

This release hardened the two things that break a live enterprise pilot: the write path that saves a memory, and the data-handling story behind it. It shipped alongside our first enterprise pilot’s opening week — and much of what changed was in service of keeping that engagement solid and honest about where your data lives.

Highlights

Usage you can actually see — an anonymized activity record

Every tool call now writes a single anonymized row to a private activity record: which tool ran, for which account, how big the request was — but never the free text you sent. It’s the substrate for the usage reporting that follows in later releases, and it’s built anonymized-at-write, so the sensitive content never lands in the first place.

What you’ll notice: nothing, directly — this is plumbing. But it’s the plumbing that lets us answer “how is my team actually using this?” without ever storing what your team typed.

Sharing stores a reference, not a copy

When you share a perspective, we no longer copy the whole compiled bundle into our database. Instead we store a pointer to your source repository and a permission grant, then compile the perspective on demand when someone loads it. You can pin a share to a fixed version or track a branch live.14

What you’ll notice: shares are lighter and always current. And there’s no second copy of your knowledge sitting on our servers — your repository stays the single canonical source.

Saving a memory no longer needs a title

remember now generates a short, readable id for your memory when you don’t supply one, with a plain fallback if generation hiccups. This closes a crash that had been silently failing title-less saves in production.

What you’ll notice: you can save a memory without stopping to name it. It just works.

The pilot behind the release

Our first enterprise pilot — a mid-size B2B software firm — opened its Phase-1 run during this window, and the signal was immediate: the team converged, inside nine days, on a single clear job.15 They weren’t exploring open-endedly the way early pilots usually do; they pointed the product at turning their recurring Architecture Review Board conversations into durable, queryable memory. That convergence is the closest thing to product-market-fit feedback we’ve had from a paying customer, and it named a repeatable shape we can sell into other engineering organizations.16

Fixes & Improvements

  • Bundled production resilience patches: retry on a version-race, guard against an empty snapshot key, and a network-retry config for repository access.
  • The activity record now coerces its timestamp correctly — writes had been silently not landing.
  • Content-derived fields are dropped from the activity summary by design, keeping it aligned with a zero-data-retention posture.
  • Test fixtures scrubbed of real customer content (a real review topic, an employee name, an email) and replaced with generic fictional data.
  • Database credentials are now redacted from connection strings before any logging.
  • Docs pages carry legal links and copyright in the footer; fully-unlisted pages now carry noindex.

This entry is a historical backfill, published as part of the changelog rebuild.

Footnotes

What’s New — April 7 to May 7, 2026

We have our first enterprise pilot. A mid-size B2B enterprise software firm in logistics signed up for the Team tier on April 30 to begin a two-phase POC.17 The 30 days that led there were heavy on the proxy/agent layer, public docs, and corrections to the product story — most importantly, aswritten is not a phone number. It’s curated expertise installation, and SMS is just one distribution channel.18

The Big Picture

Three things shifted this month:

  1. The agent layer is real. You can now create proxy deployments — SMS or chat agents that work from a perspective — directly through your AI conversation.19 This is the substrate the new pilot is running on.
  2. Sharing got safer. New /transform and /public skills let you filter, prune, and anonymize a perspective before sharing it publicly.20 No more all-or-nothing shares.
  3. Docs are live. docs.aswritten.ai got a full sweep ahead of the first non-familiar onboarding. New “Asking the Perspective Well” guide, About and FAQ pages, plus updated privacy and terms for the perspective model.

New Features

Create deployments from your AI

You can now spin up a proxy deployment — an SMS or chat agent backed by a perspective — without leaving your conversation. Tell your AI you want to deploy your perspective, and it walks you through it. Optionally include a first message to kick off the conversation immediately.

Try it: “Deploy this perspective as an SMS agent for [purpose].” Your AI calls aswritten_deploy, returns the deployment details, and (if you want) sends an opening message to the recipient.

What you’ll notice: Deployment is just another conversation. No dashboard, no console, no wizards. The same primitive that powers remember and cite, applied to the agent layer.

Note: During the soft-launch window, deploy is admin-gated. If you’d like access for a specific use case, send feedback and we’ll turn it on.

/transform and /public — share perspectives safely

Before, sharing a perspective was all-or-nothing. Now there’s a Claude Code skill that lets you transform a perspective into a derivative version: filter to a domain, prune sensitive memories, anonymize people and places, condense for clarity. /public is the same tool with a public-filter template pre-loaded.

Try it: In Claude Code, run /transform. It walks you through what to keep, what to anonymize, and what to drop. Output is a derivative branch you can share via aswritten_share.

What you’ll notice: You can finally share parts of your perspective without exposing the rest. Useful for: domain extracts (just your healthcare expertise), public versions of internal perspectives, and anonymized teaching examples.

Agents now respond in your language

If you write to a deployed agent in Spanish, French, German, or anything else, it responds in the same language. No configuration needed.

Try it: Text a deployed perspective in your non-English language of choice.

What you’ll notice: The agent reads the language of your message and matches it. The perspective is the same; the surface adapts.

Channel-aware formatting

Agents now adapt their formatting to where they’re running. SMS replies stay under the 600-character hard limit. Slack uses mrkdwn formatting and respects its 1500-char limit. The channel comes from the session — no hardcoded “this is SMS” hacks anywhere in the prompt.

What you’ll notice: Replies look right wherever they appear. SMS feels like SMS, Slack feels like Slack.

Memory write protection

Saving a memory directly to a trunk branch (main or dev) now requires explicit confirmation. The confirm_protected_write tool is visible in your tool list so you can see when this is happening.

Try it: Save a memory while on main. Your AI will ask before writing. Confirm to proceed, or switch branches first.

What you’ll notice: Fewer accidental commits to trunk. The confirmation is one extra tap; the safety is permanent.

Improvements

Narrative footnotes are now the default

When your AI cites a claim, it renders the full narrative paragraph from the cite tool by default — who said what, in what context, with what conviction, and what changed.21 Compact one-line footnotes still exist but are reserved for the rare case where dozens of adjacent low-stakes citations would smother the work.

What you’ll notice: Citations carry their full provenance. You can read a footnote and know exactly where the claim came from.

Onboarding via codebase topic-analysis

If you’re a technical user with an existing codebase, you don’t need to write memories from scratch to get started. Your AI can run a topic-analysis pass over your code and surface the candidate concepts to memorialize. This is closer to “interview the codebase” than “ingest the codebase.”

Try it: “Analyze this repo and suggest what’s worth saving as memories.”

What you’ll notice: The onboarding ramp is shorter. You start with a draft graph and edit, rather than facing an empty perspective.

Faster, more reliable reads

Read tools (perspective, cite, introspect) now resolve the default branch from your actual repo configuration instead of assuming main. Loading a large perspective no longer runs out of memory. Reviews on branches with special characters in the name no longer break.

docs.aswritten.ai

A full sweep:

  • Asking the Perspective Well — a new how-to on getting useful answers from a loaded perspective
  • About and FAQ rewritten for the broader audience
  • GitHub access requirements corrected (you don’t always need it)
  • Privacy and terms updated for the perspective model
  • Account-role names clarified, with the sign-up flow fixed to match

Fixes

  • Front draft mode now detects teammate replies from message history correctly
  • First-message deployments work end-to-end (status check, empty history, opening prompt, conversation creation)
  • Stale legal drafts from February removed; current versions live at docs.aswritten.ai

What’s Coming Next

  • Phase 1 of the pilot runs through approximately June 29. We’re paying close attention to what the chatbot deployment surfaces about the AI-resistant cohort inside an enterprise — that’s where the next tier signal will come from.
  • Perspective transforms with temporality. During a customer demo on May 1, the agent surfaced speculative claims as if they were settled. The next round of perspective work distinguishes “hypothesis raised in conversation” from “decided.”22
  • More public perspectives. With /public shipped, we’re starting to extract domain perspectives (healthcare matching is the leading candidate) for share-by-link distribution.

Feedback

Tell us what’s working and what’s not. Use the feedback tool from your AI: “I want to send feedback to aswritten.” Reaches us via SMS through Front — we read everything.

38 knowledge updates. ~150 commits. 1 first enterprise pilot. 30 days.

Coverage: 6/8 cited claims grounded (75%). The two uncommitted claims (channel-aware formatting; trunk-write confirmation) are recent product changes not yet captured in the perspective graph.

Footnotes

What’s New — March 20 to April 7, 2026

We’ve been conflating product features and internal automation. The March 26 scoping session made that visible and we cut hard: 10+ tools down to 5, everything else moved to org-only skills or removed entirely.23 The pipeline went from async-and-sometimes-broken to synchronous-and-atomic. We onboarded our first paying customer.24 Here’s what changed and how to try it.

The Big Picture

aswritten is now five tools: perspective, cite, introspect, remember, and review.25 Every tool name is a word you’d use in conversation.26 If you used the product before this update, you’ll notice it’s cleaner — fewer options, but each one does its job well.

We also renamed the plans and clarified what you get on each:

Plan Price Tools What you get
Free $0 perspective, cite Load and use perspectives. Verify where claims come from. Read-only — you can’t save or review.27
Expert $81/mo + remember, forget, review, introspect, share Single user.28 Save memories, review extractions, explore gaps. Share your perspective — static shares scoped by email or public ID. Repo provisioned automatically, no GitHub needed.29 Optionally connect GitHub for multi-repo and perspective version control.
Team $400/mo Same tools, up to 10 users Everything in Expert, plus collaborative editing of the perspective. Up to 10 users working on the same knowledge base.30 Connect GitHub for multi-repo and version control.
Organization $4K/mo + SOW Unlimited users Statement of work for setup, implementation, and maintenance. Unlimited seats. Optional on-prem, compliance, custom ontology.31

If you were on “Individual,” you’re now on Expert. If you were on “Publisher,” you’re now on Team. Your access didn’t change — just the names.

New Features

Remember is now synchronous and reliable

Previously, when you saved a memory, extraction happened in the background — sometimes it worked, sometimes it failed silently, and you’d never know which until you checked back later. Now remember extracts before it saves.32 If extraction fails, nothing is committed. If it succeeds, you get the result back in the same conversation: a summary of what was extracted, which areas of your perspective were affected, and an offer to review the changes right there.

It’s not fast — extraction takes 2-5 minutes depending on the length and complexity of the memory.33 But it’s honest. You’ll see a progress indicator while it works, and when it finishes, you know the extraction actually happened.

Try it: Save a memory about something you know well. Wait for the extraction to complete (2-5 min). The response will include a transaction summary and review instructions. If something looks wrong in the extraction, you can review it immediately instead of discovering the problem later.

What you’ll notice: No more mystery extractions. No more checking back to see if your memory was processed. It either works or it tells you why it didn’t. The wait is real, but so is the result.

Share your perspective with anyone

You can now share your perspective using a human-readable ID34 — something like “yoga-martinez-brooklyn-dana-a3b1.” The person receiving it doesn’t need a GitHub account, doesn’t need to pay, and doesn’t need to set anything up. They load the shared perspective and their AI immediately has your expertise available.

Try it: Ask your AI to share your perspective. You’ll get a shareable ID. Send it to someone who uses Claude Code or any MCP-compatible client. They call aswritten_perspective(id="your-share-id") and they’re working from your knowledge.

What you’ll notice: This is how you distribute your expertise. No marketplace needed — you share it directly with the people who need it.

Forget: explicit retraction tool

You could always update or shift knowledge by saving new memories that supersede old ones — the extraction pipeline handles that. Forget makes removal explicit.35 Instead of saving a new memory that contradicts the old one, you can directly retract knowledge from your perspective. It generates retraction transactions that cleanly remove specific claims.

Try it: If there’s something in your perspective that’s no longer true or shouldn’t be there, tell your AI: “I need to forget [topic].” It will identify the relevant knowledge and generate retraction transactions.

What you’ll notice: The difference from remember is intent. Remember adds or updates. Forget removes. Both go through the same extraction pipeline — forget just generates DELETE operations instead of INSERTs.

Review right after saving

When you save a memory, the response now includes a transaction summary and review instructions.36 You can review immediately — the quality gate moved from async PR-based to synchronous in-conversation.37

Try it: After your next remember, look at the response. It will offer to start a review. Say yes. The review examines whether the extraction accurately captured what you said.

What you’ll notice: The quality gate moved from “eventually, on a PR” to “right now, in your conversation.”

Feedback: tell us what’s broken

New tool: feedback. Report issues, share reactions, or ask questions directly from your workflow. It reaches us via SMS through Front.38 No support tickets, no email, no context switching.

Try it: Tell your AI: “I want to send feedback to aswritten.” Describe what happened. We’ll get it immediately with your session context included.

Introspect now includes focused subgraph retrieval

If you used the old “scope” tool to narrow down your perspective to a specific topic — that’s now built into introspect. Scope’s subgraph retrieval is now a mode of introspect, triggered by the focus parameter.39

Try it: Ask your AI: “What does my perspective know about [topic]?” The introspect tool with a focus will return existing knowledge, gaps, and suggested questions — all scoped to that topic.

Improvements

Simpler tool surface

We removed: scope (merged into introspect), refract, register, stories, notifications, discoveries, and the memories source tool.40 These were either duplicating what the five core tools do or were internal automation that didn’t belong in your workflow. The product should feel less cluttered.

Tool and language renames

If you’ve been using the product, you know these tools by their old names. Here’s the mapping:

Before After Why
compile perspective “Compile” described the mechanism. “Perspective” describes what you get.41
annotate cite “Annotate” was vague. “Cite” says exactly what it does — verify where claims come from.
start_review review Simpler. Also folds in list_open_reviews — one tool, not two.
scope introspect (with focus) Scope’s subgraph retrieval is now a mode of introspect, triggered by the focus parameter.
“collective memory” perspective The product concept, not just the tool. Your perspective is the installed expertise your AI works from.

Every piece of product language — prompts, tool descriptions, error messages — has been updated. If you see old terminology anywhere, that’s a bug — let us know via the feedback tool.

Migration: what you need to do

The renames and tool changes require a one-time update on your end:

Claude Code users: We’ll push a scaffold update to your repo. When you see the update prompt, accept it — this updates your .aswritten/ configuration and project instructions to use the new tool names.

Claude Desktop users: The scaffold update doesn’t reach your project instructions automatically. You’ll need to manually copy the updated aswritten section from your repo’s CLAUDE.md (or from the instructions we provide) into your Claude project settings. Without this, your AI will still try to call compile instead of perspective and get errors.

If you hit issues after the update, use the feedback tool or just let us know.

New docs site: docs.aswritten.ai

The documentation now lives at docs.aswritten.ai. Seven pages covering setup, onboarding, the product manual, pricing, FAQ, and a case study of how we use aswritten on ourselves.

  • Quick start — 5 minutes to get connected, whether you’re on Claude Code, Claude Desktop, or another MCP client
  • Onboarding guide — Step-by-step from first connection through your first memory, extraction, and perspective load
  • Product manual — How perspectives, memories, transactions, and conviction levels work
  • Pricing — The tier table above, with feature details
  • FAQ — The questions beta users and prospects have actually asked
  • Case study — How aswritten.ai uses its own product internally (1,477 nodes in the knowledge graph, multi-agent coordination, auto-generated docs)

The site is static (Jekyll on GitHub Pages), versions with the code, and auto-deploys on push to main. All content was updated for the April 9 terminology — Expert/Team/Organization, perspective/cite/review.

Faster perspective loading

Compiled perspectives are now cached in a database instead of committed to GitHub.42 This means perspective loads faster and your git history isn’t cluttered with snapshot commits.

No more timeout drops

Long operations (remember, cite, introspect) now send keep-alive signals to prevent connection drops. If you previously experienced timeouts during extraction, that should be resolved.

Fixes

  • Remember no longer defaults to “analysis” mode — it correctly defaults to “add” (this was causing some memories to not save)
  • Sharing perspectives via API key auth now works correctly
  • Email notifications now show the actual memory filename, not a dash
  • The feedback tool correctly handles optional fields (phone, email, context)
  • Forget connections are properly wired (were accidentally dropped in a prior merge)
  • Review no longer routes content reviews to the wrong handler

What’s Coming Next

  • April 9: Public launch.43 Beta testing is done. We’re opening up to everyone. Your feedback over the past months shaped what shipped — thank you.
  • Interview series. We’re starting a podcast/interview format where we talk to experts about their work and turn the conversation into an installable perspective — three outputs from one conversation.44
  • Review improvements. The review tool is getting smarter about what it examines and how it presents shifts in your perspective.
  • Content from your perspective. Early work on turning a perspective into publishable material — drafts, changelogs, and idea generation, all grounded in your knowledge graph.

Feedback

The easiest way to tell us what’s working (or not): use the feedback tool directly in your session. Say “I want to send feedback to aswritten” and describe what happened. We get it immediately.

Or just reply to this message. We read everything.

656 commits. 19 knowledge updates. 1 first paying customer. 18 days.

Coverage: 22/22 claims grounded (100%). Every factual assertion in this changelog was verified against aswritten’s own perspective using the cite tool — each claim traces back to a specific memory, person, and decision. The footnotes below show the full provenance chain. This document is itself a demonstration of what aswritten does: organizational knowledge, installed into AI, cited at the point of use.

Footnotes

  1. During the June 16, 2026 build session, Scarlet resolved a critical flakiness issue by shifting how the system reads its own knowledge graph: “Every internal consumer of the perspective — extraction, validation, summarization, citation, introspection, and the customer-facing deployment proxy — now reads the graph by navigating its collapsed digest and expanding only what it needs, rather than receiving the whole compiled snapshot embedded in its prompt.” This release completes that decision’s write side: the digest refreshes incrementally on every save. The underlying principle — the digest is a lossy index over a lossless store; the index never gates the store — is bedrock (principle-level). decision → extended to incremental regeneration. ↩

  2. The battery methodology is itself a recorded organizational decision: iterate in batches, then run the full pre-registered comparison once, at the end, against the converged pipeline — rather than continuously judging every intermediate state. The July 4 merge was the first release gated this way, with the verdict memo and per-case evidence committed to the repository. decision. ↩

  3. Grounded in the audit-module work shipped in Pilot Hardening (v2026.05.18) and extended here: per-call outcome records now carry model list, call count, cache hit tokens, and dollars, joined to the save that incurred them. (extends the v2026.05.18 audit foundation.) ↩

  4. Contributed by Scarlet while diagnosing why every staging save was failing under branch protection. Settled as a principle:

    The write flow attempts the direct commit first. Only when GitHub rejects it with a protected-branch error does the flow coin a save branch and ensure a pull request instead. An always-PR model was explicitly considered and rejected — it would add friction exactly where the product promises none, and break the two direct-to-branch constituencies: org users on working branches and single-stream users with no branching model. principle, Jul 1.

    ↩

  5. Contributed by Scarlet in a design review on response ordering. Settled as a principle of the core read architecture:

    The top of the prompt must be consistent whenever possible — a strong argument that the perspective is never reordered and that the initial perspective call returns the same thing whenever possible. The stable skeleton leads and the per-call focus trails, ordered by volatility so a prompt cache can hold the stable prefix. Extends an honesty bound: response ordering alone doesn’t buy cross-call reuse, because varying content can precede the result — the stable skeleton is the precondition that makes the perspective injectable as a stable block. principle, Jul 1.

    ↩

  6. Contributed by an outside advisor and prospective design partner — a fellow founder building adjacent knowledge-graph infrastructure — during a first call, captured by Scarlet. Recorded as a claim, framed as the strongest peer validation to date:

    [the advisor] independently arrived at nearly the same architecture as aswritten. This call is the strongest peer-validation of the core technical bets to date. [He] chose SPARQL Update unprompted; Scarlet had already chosen it. He is positioned as peer, near-term customer, and possible downstream licensing partner — not a competitor. Adjacent: a follow-up demo where he handed Scarlet the clearest sellable use case anyone had offered, with the relationship warming from there. claim, Jun 4.

    ↩

  7. Contributed by Scarlet during the read-layer build session, recorded as a principle:

    Every internal consumer of the perspective — extraction, validation, summarization, citation, introspection, and the customer-facing deployment proxy — now reads the graph by navigating its collapsed digest and expanding only what it needs, rather than receiving the whole compiled snapshot embedded in its prompt. The reliability case and the architecture case are the same move: the compiled snapshot had grown to roughly half a million tokens and was killing the provider stream at the prose-to-tool-call boundary. Navigation drops per-call context by an order of magnitude, off the long-context path entirely. Extends the recognition-aid design of the map itself. principle, Jun 16.

    ↩

  8. Contributed by Scarlet, recorded as a principle that guards against reductionism:

    The digest is a lossy index over a lossless store; the index never gates the store; it accelerates the recognized path without foreclosing novel readings. An interpretive summary is safe only because the novel reading is always one expansion away — “recognition precedes creation.” Adjacent: the later rule that map selection decides richness only, while visibility is guaranteed for every region, so nothing is ever hidden. principle, Jun 16.

    ↩

  9. Contributed by Scarlet after she caught the premature ship, settled as a principle on validation:

    Smokes prove the pipeline runs; only the pre-registered battery proves quality parity — never substitute one for the other. It superseded a session where context pressure had eroded the evaluation down to whatever ran green fastest. The battery had been committed first, precisely so the comparison couldn’t be bent to fit the result — and shipping the change being measured collapsed the clean baseline, which is why it was reverted. Extended a week later into an iterative-batch methodology that keeps the anti-drift protection while letting the battery converge honestly. principle, Jun 16.

    ↩

  10. Contributed by Scarlet during the process-redesign sessions, settled as a principle:

    Repo-native project management replaces Notion as the canonical state model — Backlog is the work-state registry, repo is the source of truth. It inverted the prior rule, where the external tool was canonical and the backlog was just a journal, consolidating the team’s state directly into the development environment. principle, Jun 9-12.

    ↩

  11. Contributed by Scarlet during a three-week cohort analysis of the enterprise pilot. Recorded as a principle about how to read adoption:

    Aggregate metrics inherit the heaviest user’s shape and hide whether a durable core of habitual users is forming and whether early-trial users are quietly attriting. The methodological principle: analyze per-user over time, never in aggregate. It corrected a composition-trap misreading, where an apparent aggregate “read-to-write flip” looked like users maturing but was really one heavy user deepening while early-trial users churned — the population changed, not the behavior. Adjacent: the decision to deliver these analytics through the usage tool rather than a separate dashboard, reinforcing that the agent is the operations interface. principle, Jun 8.

    ↩

  12. Contributed by Scarlet in a pitch-reframe review, settled as a decision that resolves the apparent B2C-vs-enterprise tension:

    Expert, Team, and Org tiers are a continuum of one use case differentiated only by the number of people writing to and consuming the perspective — not by distinct market segments. The core use — capturing decision-making over time and driving AI from the result — is identical whether one person or a whole organization does it. Adjacent: the Expert tier read as a natural feeder into Team and Organization rather than a separate business. decision, May 21.

    ↩

  13. Contributed by Scarlet across the May pitch-reframe sessions, settled as a decision naming the central organizing frame:

    What a recurring decision body does — an Architecture Review Board, an investment committee, a law firm’s partners’ meeting, a clinical case conference — is steering a process of decisions: a group, or a person, recurringly deciding how the work should go. Governance is one species of this genus; steering covers all three of the product’s use cases. Extends into a hard positioning constraint — the product is always the memory substrate, read at the start of the work and written at the end, and never the steering loop itself. Delta: supersedes “governance software” framing, which reads as compliance tooling. decision, May 2026.

    ↩

  14. Contributed by Scarlet during the ingestion-protocol review, settled as a decision on data sovereignty:

    User-owned connected repo is the default for rich ingestion. Org-managed repos permitted behind an explicit consent gate: protocol discloses “this stores verbatim content with us” and proceeds on consent. It operationalizes the bedrock principle that the customer’s repository is canonical and server-side artifacts stay strictly derived and rebuildable — data sovereignty as a trust differentiator rather than a compliance checkbox. Adjacent: the authority-confusion failure mode, which explains why downstream agents need one unambiguous canonical source. Delta: replaces materialized share bundles with compile-on-demand from the source repo. decision, Jun 2026.

    ↩

  15. Contributed by Scarlet during her review of the pilot’s first nine days, reading production logs against the engagement’s opening week. Recorded as a claim — an early but striking read on how fast organizational value lands in a structured, high-cadence review process:

    The team converged on a single clear use case within the first nine days: turning Architecture Review Board conversations into durable, queryable organizational memory. It extends the foundational decision to run the pilot inside the firm’s daily Architecture Review Board — a bounded venue with a finite technical audience and a clear success metric. Where typical enterprise pilots spend a first month in open-ended exploration, this engineering-governance context proved immediately receptive. Adjacent: the convergence-speed observation, tracked as the pilot’s most novel signal. claim, May 2026.

    ↩

  16. Contributed by Scarlet from the pilot’s first weeks. Recorded as a claim that “governance knowledge capture” is a real, concrete, sellable use case — the firm’s chief architect and his team put the product to daily work against a live review cadence, and their success criteria (the deployed agent is representative of the architect; real value is visible; other team members hold useful conversations without him) became direct product-market-fit evidence. It sits inside the broader positioning of governing a human decision process as a repeatable enterprise category. claim, May 2026. ↩

  17. Contributed by the chief architect at the pilot firm on April 30, 2026, during the commencement of Phase 1 of the POC. Recorded as a principle — a bedrock milestone for the organization. Confidence is high: it reflects a direct financial transaction and contractual obligation. Sits as the primary proof point for the Team tier’s viability. Delta: supersedes the prior trial-only state; converts the relationship into the first paid enterprise engagement in our history. principle, Apr 30. ↩

  18. Contributed by the founder during a channel strategy correction session on April 28, 2026. Settled as a decision — an experimental tagline had been treated as core identity, and the founder reset it. Confidence is high: this is an explicit correction. It sits at the root of the product’s “what is it” framing. Delta: supersedes the “product is a phone number” tagline, reframing SMS as a distribution channel rather than the product’s identity. decision, Apr 28. ↩

  19. Contributed by the founder on April 13, 2026, in the course of design work on the agent deployment layer. A settled decision grounded in the goal-directed agent primitive. Confidence is high. It positions the proxy as a dynamic extension of the principal — a “clone-that-grows” rather than a static chatbot. Delta: shifts the agent-layer model from static RAG-based bots to evolving proxies that sharpen through real interactions. decision, Apr 13. ↩

  20. Contributed by the founder on April 14, 2026, during a design session on perspective transforms. An asserted claim about the functionality of the transform skill. Confidence is moderate: it describes a feature for permanent forks and PII stripping. Sits alongside the architecture for public perspective modules. Delta: clarifies that /transform is for structural changes (anonymization, pruning) rather than ephemeral viewing lenses. claim, Apr 14. ↩

  21. Contributed by the founder on March 19, 2026, during the V1 strategy session. A principle of the “Interview → Save → Draft → Annotate” pattern. Confidence is high — this is the core quality control mechanism for all strategic drafting. Sits as a prerequisite for the “Provenance / Citation” moment of value. Delta: established narrative footnotes as the default over compact markers, ensuring the “why” is preserved in every cited claim. principle, Mar 19. ↩

  22. Contributed by the chief architect at the pilot firm and the founder on May 1, 2026, following a production demo where speculative claims surfaced in the customer’s worldview as if they were settled. A settled decision to add temporal markers to the knowledge graph. Confidence is very high — both the founder and the pilot customer independently reached the same conclusion. Delta: shifts the system from a flat conviction model to one that distinguishes “now” from “speculative” content. decision, May 1. ↩

  23. During the March 26 scoping session, the founder established a bedrock principle to eliminate the “Admin” tier. This decision was driven by the need to separate internal organizational automation from the user-facing product. Knowledge formerly restricted to admins was moved to local skills or direct file access. This sits at the core of the “Separation Principle” which dictates that the product should only ship a bounded set of behaviors. principle, Mar 26. ↩

  24. This records the onboarding of the first paying customer. The chief architect of an enterprise software company upgraded to the Team plan during an onboarding call on March 26, 2026. This transaction validated the $400/month price point for enterprise AI budgets and marked the transition from beta testing to active revenue generation. principle, Mar 26. ↩

  25. As of April 6, 2026, the user-facing tool surface has been finalized as a bedrock principle consisting of five core tools. This represents a significant slimming from the original 10+ tools, focusing the product on the essential loop of installing, citing, and growing expertise. principle, Apr 6. ↩

  26. In a design session on March 30, 2026, the founder established the bedrock principle that tool names must not leak implementation details. Engineering metaphors like “compile” were replaced with conversational words like “perspective” to ensure the product remains accessible to non-technical users. principle, Mar 30. ↩

  27. The Free tier was defined as a bedrock principle during the March 31 design session. It is explicitly read-only, serving as the primary on-ramp for users to experience the value of perspectives and citations before upgrading to the Expert tier for write capabilities. principle, Mar 31. ↩

  28. The tier structure was finalized as a bedrock principle on March 23, 2026. The “Individual” tier became “Expert” at $81/month, adding the ability to build and share personal graphs. This rename aligns the pricing with the user’s behavior rather than their organization size. principle, Mar 23. ↩

  29. The removal of GitHub as a prerequisite for initial users was established as a bedrock principle for the soft launch. This allows users to have a provisioned repository automatically, lowering the technical barrier to entry for the SMB market. principle, Mar 20. ↩

  30. The Team tier (formerly Publisher) was defined as a bedrock principle in Strategy Document V1. It provides collaborative editing for up to 10 users, allowing a shared worldview to be built across a small organization. principle, Strategy Document V1. ↩

  31. The Organization tier is defined by a bedrock principle of high-touch service. It targets users who require expert-led extraction and custom ontology development, with on-prem and compliance features acting as requirements-driven add-ons. principle, Mar 17. ↩

  32. The integration of extraction into the save loop was established as a bedrock principle on March 31. This ensures that every memory saved is immediately processed into the worldview, enabling a synchronous review flow within the same conversation. principle, Mar 31. ↩

  33. This settled decision is based on E2E testing of the extraction pipeline, which recorded a processing time of 221 seconds (approximately 3.7 minutes). This grounds the 2-5 minute extraction claim in empirical performance data. decision, Feb 25. ↩

  34. The use of human-readable IDs for sharing perspectives was established as a bedrock principle on March 30. IDs are generated from word frequency of transaction stems plus a short hash, allowing for easy distribution of expertise without requiring users to manage complex repository URLs or GitHub handles. principle, Mar 30. ↩

  35. The inclusion of “forget” in the core tool surface was established as a bedrock principle to make knowledge retraction explicit and conversational, matching the aswritten philosophy of processing content over polished content. principle, Mar 30. ↩

  36. The return value structure for the remember tool was established as a bedrock principle on March 31. By including summaries and review instructions directly in the tool response, the AI can immediately guide the user through the review process without async delays. principle, Mar 31. ↩

  37. The shift to synchronous review for the Expert tier was established as a bedrock principle. This eliminates the complexity of PRs and branching for individual users, moving the quality gate directly into the conversation flow. principle, Mar 31. ↩

  38. The feedback tool’s architecture was established as a bedrock principle on March 26. It reaches the team via SMS/email, serving as the primary support mechanism by ensuring a personal response within minutes. principle, Mar 26. ↩

  39. The absorption of “scope” into “introspect” was finalized as a bedrock principle on April 6. This consolidation reduces tool density while maintaining the ability to retrieve specific subgraphs based on a focus parameter. When focus is provided, introspect returns the relevant slice of your perspective, what’s known, what’s missing, and suggested questions. principle, Apr 6. ↩

  40. The removal of these tools was a settled decision made during the March 26 scoping session. They were reclassified as internal organizational automation rather than core product features — moved to local skills or direct file access. decision, Mar 26. ↩

  41. The renaming of core tools was established as a bedrock principle on March 30. “Perspective” replaced “compile” and “collective memory” to better reflect the product’s value as a way of thinking rather than just a data assembly process. The tool name IS the product’s core primitive. principle, Mar 30. ↩

  42. The move to database-backed snapshot caching was established as a bedrock principle on March 31. This architectural shift resolves memory issues caused by large payloads committed to GitHub and ensures that compiled perspectives are consistent and secure. principle, Mar 31. ↩

  43. The public launch date was refined to April 9 as a bedrock principle during a March 31 planning call. This shift allowed April 1 to be used as a forcing function for outreach while providing a final week for polish and scheduling. principle, Mar 31. ↩

  44. The “three outputs from one conversation” model was a settled decision reached with a design advisor on March 23. One interview produces: (1) an installable perspective for the expert, (2) a podcast episode or content piece, (3) a live demo of the product working. This model collapses sales, onboarding, and marketing into a single event, creating a content flywheel that builds the supply side. decision, Mar 23. ↩

© 2026 Synthetic Identity Co. d/b/a Aswritten.ai · Privacy · Terms · Trust · aswritten.ai
This site uses Just the Docs, a documentation theme for Jekyll.