diff --git a/docs/compare-to-tanstack.md b/docs/compare-to-tanstack.md
index 11941a9..2740554 100644
--- a/docs/compare-to-tanstack.md
+++ b/docs/compare-to-tanstack.md
@@ -1,3 +1,3 @@
 # Migrating from Tanstack
 
-- no keys, caches function + arguments by default
+- no keys (tags don't require user to adopt naming scheme), caches function + arguments by default
diff --git a/docs/core-concepts/queries.md b/docs/core-concepts/queries.md
index 41b8e0c..cd3d20e 100644
--- a/docs/core-concepts/queries.md
+++ b/docs/core-concepts/queries.md
@@ -108,7 +108,7 @@ The `useQuery` function adds some super useful, vue specific functionality you'd
 
 ### Parameters argument is reactive
 
-When parameters for your query function change, the query is automatically updated. 
+The parameters for your query must be provided as a getter, which ensures they are reactive. When the parameters change, the query is automatically updated. The old query is disposed and a new query is created.
 
 ```ts
 import { useQuery } from '@kitbag/query'
diff --git a/docs/core-concepts/tags-invalidation.md b/docs/core-concepts/tags-invalidation.md
index 2522b9b..ef69ffe 100644
--- a/docs/core-concepts/tags-invalidation.md
+++ b/docs/core-concepts/tags-invalidation.md
@@ -1,402 +1,79 @@
 # Tags & Invalidation
 
-<!-- Tags provide a powerful way to organize and invalidate cached queries in Kitbag query. They allow you to group related queries and efficiently update your cache when data changes.
+When it comes time to refresh your query, there are a few options. First, each query has an `execute()` function which will ensure your query function gets called again.
 
-## Creating Tags
+## refreshQueryData
 
-Use the `tag` function to create query tags:
+The `refreshQueryData` utility can also be used to invalidate queries based on action and args.
 
 ```ts
-import { tag } from '@kitbag/query'
-
-// Create tags for different data types
-const userTag = tag('user')
-const postTag = tag('post')
-const commentTag = tag('comment')
-const profileTag = tag('profile')
-```
-
-Tags should represent logical groupings of your data:
-
-```ts
-// Domain-based tags
-const userTag = tag('user')
-const orderTag = tag('order')
-const productTag = tag('product')
-
-// Feature-based tags
-const dashboardTag = tag('dashboard')
-const settingsTag = tag('settings')
-const reportsTag = tag('reports')
-```
-
-## Tagging Queries
-
-Add tags to your queries to group them logically:
-
-```ts
-const userQuery = query('user', fetchUser, {
-  tags: [userTag, profileTag]
-})
-
-const userPostsQuery = query('user-posts', fetchUserPosts, {
-  tags: [userTag, postTag]
-})
-
-const postCommentsQuery = query('post-comments', fetchPostComments, {
-  tags: [postTag, commentTag]
-})
-```
-
-## Cache Invalidation
-
-Invalidate all queries with specific tags:
-
-```ts
-import { createQueryClient } from '@kitbag/query'
-
-const { queryClient } = createQueryClient()
-
-// Invalidate all user-related queries
-queryClient.invalidate(userTag)
-
-// Invalidate multiple tags at once
-queryClient.invalidate([userTag, profileTag])
-```
-
-### Automatic Invalidation in Mutations
-
-Set up automatic invalidation when mutations succeed:
-
-```ts
-const updateUserMutation = query.mutation(
-  async (userData: UpdateUserData) => {
-    const response = await fetch(`/api/users/${userData.id}`, {
-      method: 'PUT',
-      body: JSON.stringify(userData)
-    })
-    return response.json()
-  },
-  {
-    // Automatically invalidate these tags on success
-    invalidateTags: [userTag, profileTag]
-  }
-)
-```
-
-## Tag Strategies
-
-### Hierarchical Tags
-
-Organize tags in a hierarchy for fine-grained control:
-
-```ts
-// General to specific
-const dataTag = tag('data')
-const userDataTag = tag('user-data')
-const userProfileDataTag = tag('user-profile-data')
-
-const userProfileQuery = query('user-profile', fetchUserProfile, {
-  tags: [dataTag, userDataTag, userProfileDataTag]
-})
-
-// Invalidating dataTag invalidates everything
-// Invalidating userDataTag invalidates all user-related data
-// Invalidating userProfileDataTag invalidates only profile data
-```
-
-### Entity-Based Tags
-
-Tag queries by the entities they involve:
-
-```ts
-const userTag = tag('user')
-const postTag = tag('post')
-
-// Queries involving users
-const userQuery = query('user', fetchUser, { tags: [userTag] })
-const usersListQuery = query('users-list', fetchUsers, { tags: [userTag] })
-
-// Queries involving both users and posts
-const userPostsQuery = query('user-posts', fetchUserPosts, { 
-  tags: [userTag, postTag] 
-})
-
-// When a user is updated, all user-related queries are invalidated
-// When a post is created, all post-related queries are invalidated
-```
-
-### Feature-Based Tags
-
-Group queries by application features:
-
-```ts
-const dashboardTag = tag('dashboard')
-const analyticsTag = tag('analytics')
-const settingsTag = tag('settings')
-
-const dashboardDataQuery = query('dashboard-data', fetchDashboardData, {
-  tags: [dashboardTag]
-})
-
-const userAnalyticsQuery = query('user-analytics', fetchUserAnalytics, {
-  tags: [dashboardTag, analyticsTag]
-})
-
-// Refresh entire dashboard
-queryClient.invalidate(dashboardTag)
-```
-
-## Advanced Invalidation Patterns
+import { refreshQueryData } from '@kitbag/query'
+import { searchCats } from '../services/catsApi'
 
-### Conditional Invalidation
+function handleRefreshClick(): void {
+  // invalidates all queries that call searchCats
+  refreshQueryData(searchCats)
 
-Invalidate queries based on conditions:
-
-```ts
-const updateUserMutation = query.mutation(
-  async (userData: UpdateUserData) => {
-    const response = await fetch(`/api/users/${userData.id}`, {
-      method: 'PUT',
-      body: JSON.stringify(userData)
-    })
-    return response.json()
-  },
-  {
-    onSuccess: (data, variables) => {
-      // Always invalidate user data
-      queryClient.invalidate(userTag)
-      
-      // Conditionally invalidate based on what changed
-      if (variables.profilePicture) {
-        queryClient.invalidate(profileTag)
-      }
-      
-      if (variables.email) {
-        queryClient.invalidate(authTag)
-      }
-    }
-  }
-)
-```
-
-### Partial Invalidation
-
-Invalidate specific query instances:
-
-```ts
-// Invalidate user query for specific ID
-queryClient.invalidate(userQuery, [userId])
-
-// Invalidate all queries with userTag but only for specific parameters
-queryClient.invalidate(userTag, (query) => {
-  return query.params?.[0] === specificUserId
-})
+  // invalidates only queries that call searchCats with ['Himalayan']
+  refreshQueryData(searchCats, ['Himalayan'])
+}
 ```
 
-### Background Invalidation
-
-Invalidate without showing loading states:
-
-```ts
-// Silently refetch data in the background
-queryClient.invalidate(userTag, { refetchType: 'background' })
-
-// Only invalidate, don't refetch
-queryClient.invalidate(userTag, { refetchType: 'none' })
-```
+## Tags
 
-## Tag Organization Patterns
+Often we have multiple queries to different functions that are related to each other. These queries could be grouped together using a tag. The tag ensures an easy way to set or invalidate the cache for the whole group.
 
-### By Domain Model
+```vue
+<script lang="ts" setup>
+import { tag, useQuery, refreshQueryData } from '@kitbag/query'
 
-Organize tags around your domain models:
+const catsTag = tag()
 
-```ts
-// E-commerce example
-const userTag = tag('user')
-const productTag = tag('product')
-const orderTag = tag('order')
-const cartTag = tag('cart')
-const wishlistTag = tag('wishlist')
+const catNamesQuery = useQuery(randomCatNames, () => [...], { tags: [catsTag] })
+const catYearsQuery = useQuery(convertToCatYears, () => [...], { tags: [catsTag] })
+const catNappingQuery = useQuery(checkCatIsNapping, () => [...], { tags: [catsTag] })
 
-// CMS example
-const pageTag = tag('page')
-const postTag = tag('post')
-const categoryTag = tag('category')
-const authorTag = tag('author')
-const mediaTag = tag('media')
+// later
+refreshQueryData(catsTag)
+</script>
 ```
 
-### By Data Relationships
-
-Tag queries based on data relationships:
-
-```ts
-const userTag = tag('user')
-const userRelationsTag = tag('user-relations')
-
-const userQuery = query('user', fetchUser, { 
-  tags: [userTag] 
-})
-
-const userFriendsQuery = query('user-friends', fetchUserFriends, { 
-  tags: [userTag, userRelationsTag] 
-})
+Think of `tag` as a function that generates a unique identifier that helps Kitbag Query to find the query later. Since each tag generated is unique, we recommend creating and exporting your tags from a shared location.
 
-const userGroupsQuery = query('user-groups', fetchUserGroups, { 
-  tags: [userTag, userRelationsTag] 
-})
+## Tag Type
 
-// Update user profile - only invalidate direct user data
-userMutation.mutate(userData, {
-  invalidateTags: [userTag]
-})
-
-// Update friend relationship - invalidate user relations
-addFriendMutation.mutate(friendData, {
-  invalidateTags: [userRelationsTag]
-})
-```
-
-### By Access Patterns
-
-Group by how data is accessed:
+Kitbag Query also supports typed tags. Where a generic type can be added to a tag for extra type safety. By default the tag type is `unknown`. This satisfies any query, but assigning your actual type not only validates the query type but also provides improved type safety later when accessing cached data, like in `setQueryData`.
 
 ```ts
-const listTag = tag('list')       // List views
-const detailTag = tag('detail')   // Detail views
-const searchTag = tag('search')   // Search results
-
-const usersListQuery = query('users-list', fetchUsers, {
-  tags: [userTag, listTag]
-})
+import { tag, setQueryData } from '@kitbag/query'
 
-const userDetailQuery = query('user-detail', fetchUserDetail, {
-  tags: [userTag, detailTag]
-})
+const catTag = tag<Cat>()
 
-const userSearchQuery = query('user-search', searchUsers, {
-  tags: [userTag, searchTag]
-})
+// data will be type `Cat`, return type for setter is expected to be `Cat` 
+setQueryData(catTag, (data) => ...)
 ```
 
-## Best Practices
-
-### 1. Use Descriptive Tag Names
+## Tag Factories
 
-Make tag purposes clear:
+Tags can also be configured as factories, which offer a way to increase specificity through a callback you define.
 
 ```ts
-// ✅ Good
-const userProfileTag = tag('user-profile')
-const dashboardMetricsTag = tag('dashboard-metrics')
-const orderHistoryTag = tag('order-history')
+import { tag } from '@kitbag/query'
 
-// ❌ Bad
-const tag1 = tag('data1')
-const tag2 = tag('stuff')
-const tag3 = tag('things')
+export const catIdTag = tag<Cat, string>(((catId: string) => catId))
 ```
 
-### 2. Don't Over-Tag
-
-Use tags strategically, not on every query:
+Then assign tags on queries using the tags getter syntax.
 
 ```ts
-// ✅ Good - Strategic tagging
-const userQuery = query('user', fetchUser, { tags: [userTag] })
-const staticConfigQuery = query('config', fetchConfig) // No tags needed
-
-// ❌ Bad - Over-tagging
-const timestampQuery = query('timestamp', () => Date.now(), { 
-  tags: [timeTag, utilityTag, helperTag] // Unnecessary
-})
+const catsQuery = useQuery(getCat, () => [props.catId], { tags: (cat) => [catIdTag(cat.id)] })
 ```
 
-### 3. Create a Tag System
-
-Establish consistent tag naming and organization:
+This ensures that the tag is narrowed to only the queries for _this_ `catId`.
 
 ```ts
-// tags/index.ts
-export const tags = {
-  // Entities
-  user: tag('user'),
-  post: tag('post'),
-  comment: tag('comment'),
-  
-  // Features  
-  dashboard: tag('dashboard'),
-  settings: tag('settings'),
-  reports: tag('reports'),
-  
-  // Data types
-  list: tag('list'),
-  detail: tag('detail'),
-  search: tag('search')
+function save(catId: string): Promise<void> {
+  ...
+  refreshQueryData(catIdTag(catId))
 }
 ```
-
-### 4. Document Tag Relationships
-
-Document how your tags relate to each other:
-
-```ts
-/**
- * Tag Relationships:
- * 
- * userTag: All user-related queries
- *   - userProfileTag: User profile data
- *   - userSettingsTag: User settings
- *   - userActivityTag: User activity/history
- * 
- * postTag: All post-related queries
- *   - postListTag: Post lists/feeds
- *   - postDetailTag: Individual post details
- *   - postMetricsTag: Post analytics
- */
-```
-
-## Performance Considerations
-
-### Tag Granularity
-
-Balance between too broad and too specific:
-
-```ts
-// Too broad - invalidates too much
-const dataTag = tag('data') // Everything uses this
-
-// Too specific - hard to manage
-const userPage1Tag = tag('user-page-1')
-const userPage2Tag = tag('user-page-2')
-// ... hundreds of specific tags
-
-// Just right - meaningful groupings
-const userTag = tag('user')
-const userListTag = tag('user-list')
-const userProfileTag = tag('user-profile')
-```
-
-### Invalidation Frequency
-
-Consider how often you need to invalidate:
-
-```ts
-// High-frequency updates - specific tags
-const liveDataTag = tag('live-data')
-const notificationsTag = tag('notifications')
-
-// Low-frequency updates - broader tags
-const configTag = tag('config')
-const staticContentTag = tag('static-content')
-```
-
-## Next Steps
-
-Learn more about cache management:
-
-- [Caching](/core-concepts/caching) - Understanding cache behavior
-- [useQuery Composable](/composables/useQuery) - Using tags with queries
-- [Advanced Concepts](/advanced-concepts/error-handling) - Advanced cache strategies -->
\ No newline at end of file
diff --git a/src/main.ts b/src/main.ts
index 2997f67..ef5464b 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -7,12 +7,28 @@ import { MutationAction, MutationData, MutationTagsContext, MutationTagsBeforeCo
 import { QueryAction, QueryData, QueryActionArgs, QueryTags, QueryOptions, Query, AwaitedQuery } from './types/query'
 import { QueryTag, QueryTagType, QueryTagCallback, QueryTagFactory } from './types/tags'
 
-const { query, useQuery } = createQueryClient()
+const {
+  query,
+  useQuery,
+  defineQuery,
+  setQueryData,
+  refreshQueryData,
+  mutate,
+  useMutation,
+  defineMutation,
+} = createQueryClient()
 
 export {
   createQueryClient,
   tag,
-  query, useQuery
+  query,
+  useQuery,
+  defineQuery,
+  setQueryData,
+  refreshQueryData,
+  mutate,
+  useMutation,
+  defineMutation
 }
 
 export type {