Cursor reframes the IDE as an agent execution runtime — the agent is the primary process, the editor is the visualization layer.
That framing from Cursor's own team tells you everything about where the product is going. And versions 3.7 through 3.11 — released across June and early July 2026 — are the clearest expression yet of that vision.
This is the most significant batch of Cursor updates since it crossed $2B ARR. Here is every feature that matters, with practical tips for each one.
1. Design Mode — Point, Draw, Narrate UI Changes (v3.7, June 5)
Direct agents with visual prompts in Design Mode — point, draw, or narrate UI changes in the browser while agents edit the code underneath.
This is the headline feature of the v3.7 release and the one that changes how frontend work feels in Cursor.
What it does:
Multi-select elements — click two or more elements in the Cursor browser and the agent sees their code, the surrounding layout, and the visual relationships between them; ask it to make one match another, remove repeated content, or adjust a group of components at once. Voice input — narrate changes through the Design Mode overlay; the mic stays live while an agent is mid-run, so you can queue the next change by voice without waiting for the previous one to finish.
Practical workflow:
Before Design Mode: 1. Inspect element in DevTools 2. Find the component file 3. Identify the CSS class 4. Describe the change in text 5. Hope the agent understands After Design Mode: 1. Click the element in the browser 2. Say or type what you want 3. Agent edits the code directly
Tips for using Design Mode effectively:
- Use multi-select for consistency changes — "make all these buttons the same height"
- Voice input works best for spatial descriptions — "move this closer to the header"
- Design Mode for canvases makes it easier to edit artifacts and visual outputs inside the workflow — use it for reviewing AI-generated UI components before accepting
- Always review the diff before accepting — Design Mode is powerful and can affect more than the element you clicked
PHP/Laravel developers: Design Mode pairs directly with Livewire and Blade components. Click a component in the browser, describe the change, Cursor finds the Blade view and edits it.
2. Bugbot 3× Faster — /review Runs Locally (v3.7, June 10)
Cursor's code-review agent is now ~3× faster (about 90 seconds, down from ~5 minutes), 22% cheaper, and finds 10% more bugs per review. /review runs Bugbot locally to catch and fix issues before you push. Reviews sync across GitHub and GitLab, and can be configured to focus only on new PR changes.
Before — the old Bugbot:
- 4-5 minute wait per review
- Had to push to get a review
- Missed approximately 10% more issues than current version
After — Bugbot v2:
- 90 seconds — fast enough to run before every commit
- Runs locally via
/review— catches issues before they even reach GitHub - 22% cheaper — meaningful for teams running reviews on every PR
- Syncs across GitHub and GitLab — one review tool for both platforms
Setup for Laravel projects — .cursorrules review config:
markdown
# Review focus for this Laravel project When running /review: Priority 1 — Security: - SQL injection via DB::raw() without bindings - Mass assignment without $fillable - Missing authorization policy checks - env() calls outside config/ directory Priority 2 — Laravel conventions: - Validation in Controllers (should be Form Requests) - Business logic in Controllers (should be Services) - Raw model returns in API endpoints (should be Resources) - N+1 queries — missing eager loading Priority 3 — Testing: - New methods without test coverage - Missing edge case tests Skip: formatting, whitespace, comment style
Integrate with git hooks:
bash
# .git/hooks/pre-push
#!/bin/bash
echo "Running Bugbot review..."
cursor review --local --staged
if [ $? -ne 0 ]; then
echo "Bugbot found critical issues. Fix before pushing."
exit 1
fi
3. Side Chats — Ask Without Interrupting (v3.11, July 10)
Open a side chat to ask questions, explore ideas, and investigate tangents without interrupting your main agent conversation. Use /side, /btw, or the plus button at the top of the chat panel to create a new side chat that has context from the main chat. Each side chat is a durable, full agent conversation that you can follow up on, revisit later, and at-mention to pull context back into the main thread. By default, side chats focus on reading, searching, and answering.
The problem this solves:
You are halfway through a complex refactor with the main agent. You want to ask "wait, should I be using Repository pattern here?" — but asking in the main chat interrupts the agent's flow and adds noise to the conversation.
Previously: either interrupt the main agent or hold the question in your head.
Now: /side or /btw opens a parallel conversation with full context from the main thread.
Practical use cases:
Main agent: Refactoring PaymentService across 8 files Side chat 1 (/side): "What are the implications of making this class final?" Side chat 2 (/btw): "Is there a Laravel 13 pattern for this that I'm missing?" Side chat 3: "Search our codebase for similar patterns we already have" Main agent: Continues running uninterrupted
At-mentioning side chats back into main:
# In main chat @side-1 suggested using the Strategy pattern here. Can you refactor the payment method selection using that approach?
Side chat findings pull back into the main conversation context — no copy-pasting.
Tips:
- Use side chats for research questions, not implementation tasks
- Use them to ask clarification questions, research alternatives without committing to a pivot, and sanity-check a decision while the main agent continues running
- Side chats are durable — revisit them later, they do not disappear when you close the main conversation
4. Agent Transcript Search (v3.11, July 10)
Find past agent chats faster with search results that go beyond names and PR numbers. In the Agents Window, you can search agent transcripts from the command palette (Cmd+K). Cursor builds a local search index that scales search to thousands of conversations with snappy performance.
Why this matters:
Every developer has had this experience: "I remember Claude/Cursor solved this exact problem three weeks ago, but I cannot find the conversation."
Agent Transcript Search makes your entire agent history searchable — not just conversation titles, but the actual content of every session.
Practical tips:
# Search for past solutions Cmd+K → "N+1 query fix PostController" Cmd+K → "authentication middleware Laravel" Cmd+K → "database migration rollback error" # Search for patterns you used before Cmd+K → "Repository pattern implementation" Cmd+K → "Form Request custom validation rule"
Build a habit: after solving a complex problem, add a short summary comment at the end of the agent conversation. Makes it much easier to find later.
# End of agent session — add this
"Summary: Fixed N+1 query in OrderController by eager loading
user, items, and shippingAddress relationships. Also added
withCount('comments') to avoid separate count queries."
5. Team MCP Marketplace (v3.10, June 30)
Admins can now configure Team MCP servers once and distribute them across cloud agents, the agents window, IDE, and CLI. When an admin sets up Team MCP servers for cloud agents, they can make those same servers available in a team marketplace from Dashboard -> Integrations & MCP. This allows members of the team to install approved integrations locally without configuring servers themselves.
For solo developers and small teams:
This removes the overhead of each team member setting up their own MCP connections. Admin configures once — everyone gets the same connections.
For a Laravel team — admin sets up:
json
// Team MCP configuration — set once, distributed to all
{
"servers": {
"postgresql": {
"command": "mcp-server-postgres",
"args": ["postgresql://shared-dev-db/app"],
"shared": true
},
"redis": {
"command": "mcp-server-redis",
"args": ["redis://shared-redis:6379"],
"shared": true
},
"github": {
"command": "mcp-server-github",
"env": { "GITHUB_TOKEN": "${TEAM_GITHUB_TOKEN}" },
"shared": true
}
}
}
Every team member opens Cursor and instantly has database, Redis, and GitHub access — no individual configuration.
Team marketplaces now support organization groups, in addition to team-level SCIM directory groups. Marketplaces that already use SCIM directory groups keep that configuration.
6. Cursor for iOS — Public Beta (v3.9, June 29)
Open the Cursor mobile app, choose a repo, and launch an agent the same way you would on the desktop app. Pick any frontier model, describe ideas out loud with voice input, and use slash commands to guide Cursor in the right direction.
What you can do from iOS:
Use Remote Control in the Agents Window to take an agent you're running on your computer and keep directing it from your phone. Track the status of your agents with Live Activities on your lock screen. Get push notifications when an agent finishes, needs input, or is ready for review. Review demos, screenshots, logs, and diffs from your phone.
Practical workflow:
Morning commute: → Open Cursor iOS → Launch a background agent: "Refactor the UserService to use Repository pattern" → Agent runs in cloud VM → Notifications when it needs input or finishes → Review the diff on the train → Approve or request changes At desk: → Open Cursor desktop → Agent is already done → Review and merge
Tips for iOS:
- Voice input is the primary input method — describe tasks clearly and specifically
- Use iOS for launching tasks and reviewing results, not for detailed implementation direction
- Cloud agents run in isolated VMs — your laptop can be off while they work
- On Teams and Enterprise plans, admins must enable Remote Control from the Cursor Dashboard
7. Cloud Dev Environment in 10 Minutes (v3.7)
Cursor can now help you set up your dev environment in the cloud in less than 10 minutes. You can watch the agent's progress in a shared terminal session as it handles setup tasks like installing dependencies. Your environment is captured in a reusable snapshot, so future cloud agents start up faster with the ability to test changes by running your software.
What this means for Laravel developers:
Traditional cloud setup: 1. Provision server 2. Install PHP 8.3 3. Install Composer 4. Configure Nginx 5. Set up PostgreSQL 6. Configure Redis 7. Set environment variables 8. Run migrations 9. Configure queues 10. Set up Supervisor Total: 1-2 hours Cursor cloud environment: 1. Open Cursor 2. Describe the stack 3. Watch it happen in terminal 4. Snapshot saved for future agents Total: 10 minutes
Snapshot advantage: Once your environment is captured, every future cloud agent starts from that snapshot — pre-configured, pre-seeded, ready to run immediately.
8. Jira Integration
You can ask Cursor to fix bugs, add features, update tests, or investigate something described in the ticket. When the agent finishes, Jira shows completion updates and includes a link to the pull request.
Workflow:
1. Assign Jira ticket to Cursor 2. Agent reads ticket description 3. Agent implements fix/feature 4. Agent updates tests 5. Agent creates PR 6. Jira automatically shows: "Completed — PR #247" 7. You review and merge
For Laravel projects — effective Jira ticket format:
Title: Fix N+1 query on orders list endpoint Description: Endpoint: GET /api/v1/orders Issue: Fires 41 queries for 20 orders (should be 3) Root cause: Missing eager loading on user and items relationships Expected: Use Post::with(['user', 'items.product'])->paginate(20) Acceptance criteria: - Query count reduced to ≤ 5 for 20 orders - Existing tests pass - New test added verifying eager loading - No change to response format
More specific tickets = better agent output. Vague tickets produce vague implementations.
9. Auto-Review Run Mode (v3.6)
Applies to Shell, MCP, and Fetch calls: allowlisted calls run immediately, sandboxable calls run in the sandbox, and everything else goes to a classifier subagent that allows the call, tries a different approach, or asks for your approval.
This is the safety layer that makes autonomous agents practical in production codebases.
Configure it:
Settings > Cursor Settings > Agents > Run Mode Options: - Manual: approve every action - Auto (recommended): classifier decides what's safe - Full auto: everything runs without approval
For Laravel projects — allowlist safe operations:
json
// .cursor/run-mode.json
{
"allowlist": [
"php artisan test",
"php artisan migrate --database=testing",
"composer install",
"npm run build"
],
"sandbox": [
"php artisan migrate",
"php artisan db:seed"
],
"require_approval": [
"php artisan migrate --force",
"git push",
"php artisan queue:work"
]
}
10. Plan Mode in .cursor/plan Folder
Plan mode breaks down your environment, database structure, and auth setup into a file in your cursor plan folder.
Plan Mode generates a structured blueprint of your application state — particularly useful after migrations, refactors, or any significant change.
When to use it:
bash
# After a major migration cursor plan # After a team member's PR changes architecture cursor plan --diff # Before starting a large feature cursor plan --feature="payment-integration"
What it captures:
- Current database schema state
- Auth setup and middleware configuration
- Environment configuration summary
- Recent significant changes
- Potential conflicts or inconsistencies
For Laravel: Plan Mode reads your migrations, routes, middleware, and config files — generates a reference document that helps subsequent agents understand the current state of your application without reading every file.
The Bigger Picture — What These Updates Mean Together
Cursor reframes the IDE as an agent execution runtime — the agent is the primary process, the editor is the visualization layer.
Look at these updates together:
- Design Mode → agents edit UI by visual reference, not text description
- Side Chats → parallel thinking without interrupting execution
- Agent Transcript Search → your entire agent history becomes institutional knowledge
- Team MCP Marketplace → team-wide AI infrastructure configured once
- iOS app → agents run and get directed from anywhere
- Cloud environments → agents work in pre-configured VMs without your laptop
The pattern: every update removes friction between what you want and what the agent executes. Less description. Less setup. Less waiting. Less interruption.
The bar for productivity tools has permanently shifted. If your IDE can't autonomously implement features, review pull requests, and learn your project context, it already feels outdated.
For PHP and Laravel Developers Specifically
The most valuable Cursor updates for backend PHP work in this batch:
Most impactful: Bugbot 3× faster + local /review — run before every commit, catch Laravel-specific issues before they reach GitHub.
Most underrated: Team MCP Marketplace — configure your PostgreSQL, Redis, and GitHub connections once across your whole team.
Best for productivity: Side Chats — ask "is this the right Laravel pattern?" without breaking your main refactor session.
Best for future: Plan Mode — gives every new agent session an accurate picture of your current migration state and auth setup.
Update Checklist
bash
# Update Cursor to latest # Help > Check for Updates (macOS/Windows) # Or download v3.11 from cursor.com # Enable Design Mode # Settings > Features > Design Mode > Enable # Configure /review # Add .cursorrules with review focus for your project # Set up Run Mode # Settings > Agents > Run Mode > Auto # Install Cursor iOS (paid plans) # App Store > Cursor for iOS # Set up Team MCPs (team admins) # Dashboard > Integrations & MCP > Team Marketplace
Version Summary
VersionReleasedHeadline Featurev3.7June 5-10, 2026Design Mode + Bugbot 3× fasterv3.8June 17, 2026Cloud agent updatesv3.9June 29, 2026Cursor for iOSv3.10June 30, 2026Team MCP Marketplacev3.11July 10, 2026Side Chats + Agent Search
Tushar Modi — Full Stack Developer, Jaipur