TL;DR: Google has launched an agentic IDE powered by Gemini 3 Pro that enables autonomous algo trading research by controlling the browser, running backtests, analyzing results, and iteratively improving strategies using the Jesse framework—all for free.
📋 Table of Contents
Jump to any section (20 sections available)
📹 Watch the Complete Video Tutorial
📺 Title: Algo trading research with Google’s Antigravity and Gemini 3
⏱️ Duration: 618
👤 Channel: Algo-trading with Saleh
🎯 Topic: Algo Trading Research
💡 This comprehensive article is based on the tutorial above. Watch the video for visual demonstrations and detailed explanations.
Google has just launched not only the powerful Gemini 3 Pro model but also an agentic IDE—a game-changing tool that goes far beyond traditional coding assistants. Unlike existing tools like Cursor, this new IDE can autonomously control your browser, execute backtests, analyze results, and even iterate on trading strategies based on performance feedback. Best of all? It’s completely free—at least for now.
In this comprehensive guide, we’ll walk you through exactly how to set up and leverage this agentic IDE for automated algo trading research using the Jesse framework. You’ll learn how to configure custom instructions, generate and refine trading strategies, and—most impressively—enable the AI to run live backtests in your browser, evaluate results, and intelligently revert changes if performance degrades.
Why This Agentic IDE Is a Breakthrough for Algo Traders
While tools like Cursor offer AI-assisted coding, they come with significant limitations: high subscription costs (up to $200/month for heavy token usage) and limited browser automation capabilities. Google’s new agentic IDE changes the game by offering:
- Free access to advanced AI models like Gemini 3 Pro
- Full browser control—allowing the AI to interact with web dashboards
- Autonomous research loops: test → evaluate → improve or revert
- Unlimited access to Cloud Set 4.5 (a highly capable model)
This means you can now delegate complex, iterative algo trading research tasks to an AI agent that works while you sleep.
Understanding the Core Vision: AI-Powered Algo Trading Research
The ultimate goal is to create an AI agent that can:
- Write trading strategies in Python using the Jesse framework
- Modify them based on performance feedback (e.g., “reduce trades in ranging markets”)
- Launch a browser, navigate to your Jesse dashboard
- Run backtests automatically
- Analyze results (profit, drawdown, Sharpe ratio, trade count)
- Decide whether to keep or discard changes based on predefined success criteria
This transforms the AI from a passive code generator into an active research partner.
Step-by-Step Setup: Preparing Your Environment
1. Install the Agentic IDE (Anti-Gravity)
Begin by installing the IDE referred to as “Anti-Gravity” in the transcript. After installation, you’ll be greeted with a standard agent-based interface.
Note: Some users may experience issues with keyboard shortcuts not importing correctly from Cursor. Be prepared to manually reconfigure shortcuts if needed.
2. Create a New Jesse Project
If you don’t already have a Jesse project, generate one using the official command:
jesse project new my_algo_researchRefer to the Jesse documentation for detailed setup instructions.
3. Configure Your Virtual Environment
Ensure you’re using the correct Conda or virtual environment with the proper Python version required by Jesse. This prevents runtime errors during backtesting.
Feeding Custom Instructions for Algo Trading
To make the AI understand your specific needs for algo trading, you must provide custom instructions. These tell the model:
- To use Python
- To follow the Jesse framework structure
- How to format strategies, handle indicators, and manage positions
How to Implement Custom Instructions
- Visit the open-source repository shared by the creator (linked in the video description)
- Locate the file:
instructions.mmd - Copy its entire contents
- In your IDE project root, create a new file named
agents.md - Paste the copied instructions into
agents.md
This file acts as the AI’s “rulebook” for generating Jesse-compatible strategies.
Launching Your Jesse Dashboard
Once your project is ready, start the Jesse dashboard with:
jesse runBy default, it runs on http://localhost:9000 (the user in the transcript changed the port, but 9000 is standard). Open this URL in Chrome.
Default login credentials:
- Username: Not required
- Password:
test
Creating Your First Strategy with AI
1. Initialize a New Strategy in Jesse
In the Jesse dashboard:
- Go to the Strategies section
- Click Create New
- Name it (e.g.,
test_one)
This generates a boilerplate strategy file.
2. Use the Agentic IDE to Generate Code
Instead of coding manually, switch to the agentic IDE and:
- Open the strategy file (e.g.,
test_one.py) in the IDE - Select the “Fast” mode for quicker responses
- Choose the model: Gemini 3 Pro (High), but set to “Low” for speed (it’s sufficient for strategy generation)
- Attach the strategy file to your prompt
- Enter your request: “Write a golden cross strategy.”
3. Review the Generated Golden Cross Strategy
The AI produced the following logic:
# Define moving averages
short_ma = ta.sma(50, sequential=True)
long_ma = ta.sma(200, sequential=True)
# Long condition: short MA crosses above long MA
if crossover(short_ma, long_ma):
# Enter long position
qty = self.position_size()
self.buy = qty, self.price
# Exit condition
if self.is_long and crossunder(short_ma, long_ma):
self.sell = self.position.qty, self.priceWhile the creator notes they typically avoid sequential=True for simplicity, this implementation is functionally correct and includes proper position sizing and exit logic.
Running Your First Backtest
After accepting the AI-generated code:
- Return to the Jesse dashboard
- Go to Backtest
- Select your strategy (
test_one) - Set parameters:
- Timeframe: 15 minutes
- Symbol: BTC-USDT
- Exchange: Binance Perpetual Futures
- Period: Default (approx. 2 months)
- Mode: Enable Fast Mode
- Click Run
Backtest Results
| Metric | Value |
|---|---|
| Net Profit | +22% |
| Max Drawdown | -1% |
| Sharpe Ratio | 3.0 |
| Number of Trades | 38 |
Important: The creator acknowledges this is a cherry-picked period, but the strategy performs well under these conditions.
Refining Strategies: Adding Market Filters
Next, the goal was to reduce overtrading in ranging markets. The prompt given to the AI:
“The strategy is good but it is taking too many trades. Can you define some kind of filter for it to not take trades in ranging markets?”
AI’s Solution: ADX Filter
The AI correctly implemented an Average Directional Index (ADX) filter:
adx = ta.adx(14, sequential=True)
# In go_long():
if crossover(short_ma, long_ma) and adx > 25:
# Only enter if trend is strongThis is syntactically and logically correct for the Jesse framework.
Testing the Filter
After re-running the backtest with the ADX filter:
| Metric | Baseline | With ADX Filter |
|---|---|---|
| Net Profit | +22% | -4% |
| Number of Trades | 38 | 14 |
| Max Drawdown | -1% | Worsened |
While trade count dropped significantly, profitability turned negative—showing that not all filters improve performance.
Enabling Autonomous Research: The Real Breakthrough
The true power lies in instructing the AI to autonomously test, evaluate, and decide whether to keep a modification.
Advanced Prompt for Autonomous Research
“The strategy is good, but it is taking too many trades. I need you to add an ADX filter and then open the browser and run the backtest. If it improved the results, keep it. If it didn’t, remove it.”
Crucially, you must also provide:
- The exact dashboard URL (e.g.,
http://localhost:9000) - The password:
test
Browser Automation Setup
On first use, the IDE will prompt you to install a Chrome extension for browser control. Allow it and select “Always Allow” for seamless automation.
Watching the AI Conduct Live Research
Once the prompt is sent:
- The AI opens Chrome and navigates to the Jesse dashboard
- It enters the password (
test) automatically - It locates the backtest page and selects the correct strategy
- It clicks “Rerun” to execute the test with the ADX filter
- It waits for results and analyzes key metrics
Visual Indicator: Blue highlights in the IDE show when the agent is actively controlling the browser.
AI’s Autonomous Decision-Making in Action
After analyzing the backtest results, the AI generated the following summary:
“The ADX filter reduced the number of trades from 38 to 14, but it also significantly worsened the net profit from 22% to minus 4%. Based on the instruction, if it improves the result, keep it. If not, remove it. I should remove the ADX filter. I will now revert changes made to the file.”
It then automatically reverted the code to its original state and confirmed task completion.
Performance and Speed Considerations
The creator notes that the agentic IDE is currently slower than Cursor, likely due to:
- Heavy traffic (launched just one day prior)
- Free access attracting massive user volume
- Browser automation adding latency
However, for overnight research tasks, speed is less critical. You can initiate a complex experiment before bed and wake up to completed results.
Model Selection: Gemini 3 Pro vs. Cloud Set 4.5
The IDE offers access to multiple models:
| Model | Best For | Speed | Cost |
|---|---|---|---|
| Gemini 3 Pro (High) | Complex logic, debugging | Slower | Free |
| Gemini 3 Pro (Low) | Strategy generation, simple edits | Faster | Free |
| Cloud Set 4.5 | Advanced reasoning, research loops | Moderate | Free (unlimited access) |
Recommendation: Start with Gemini 3 Pro (Low) for routine tasks. Switch to High or Cloud Set 4.5 if the AI struggles with complex instructions.
Practical Use Case: Overnight Strategy Optimization
Imagine this workflow:
- At 10 PM, you prompt the AI: “Test 20 different combinations of RSI, MACD, and Bollinger Band filters on the golden cross strategy. Keep only modifications that increase Sharpe ratio above 2.5 and reduce drawdown.”
- The AI runs all tests autonomously through the night
- By 8 AM, you have a report of the top 3 performing variants—and the code is already updated
This turns hours of manual work into a hands-off, automated research pipeline.
Troubleshooting Common Issues
1. Shortcuts Not Working After Import
Solution: Manually reassign keybindings in the IDE settings.
2. Browser Automation Fails on First Run
Solution: Install the required Chrome extension when prompted and grant “Always Allow” permissions.
3. Dashboard Requires Password
Solution: Always include the password (test) in your prompt when browser access is needed.
4. Slow AI Response Times
Solution: Use “Fast” mode and “Low” model settings for simple tasks. Avoid peak usage hours if possible.
Comparing Agentic IDE vs. Cursor for Algo Trading
| Feature | Google’s Agentic IDE | Cursor |
|---|---|---|
| Cost | Free | Up to $200/month for heavy use |
| Browser Automation | Yes (advanced) | Limited or basic |
| Autonomous Research Loops | Yes | No |
| Speed | Slower (currently) | Faster |
| Token Limits | Unlimited (for now) | Strict limits on lower tiers |
Accessing the Open-Source Custom Instructions
The creator has open-sourced the custom instructions file (instructions.mmd) to help you get started. This file is essential for ensuring the AI generates Jesse-compliant code.
How to get it:
- Check the video description for the GitHub repository link
- Download
instructions.mmd - Save as
agents.mdin your project root
Future Possibilities and Community Engagement
The creator invites viewers to:
- Comment with specific experiments they’d like to see (e.g., “Can it optimize hard FX pairs?”)
- Subscribe and like the video for a chance to win 1 million Bunk tokens
Potential future explorations include:
- Multi-strategy ensemble testing
- Walk-forward analysis automation
- Integration with live trading (with safety guards)
Final Thoughts: The Dawn of Autonomous Algo Research
Google’s agentic IDE represents a paradigm shift in algorithmic trading. For the first time, traders can delegate the entire research cycle—from idea to validation—to an AI agent that works tirelessly, evaluates outcomes objectively, and learns from each experiment.
While still in its early days and occasionally slow, the fact that this capability is free and highly capable makes it an essential tool for any serious algo trader.
Your Action Plan
- Install the agentic IDE
- Set up a Jesse project
- Add the
agents.mdcustom instructions - Run a simple golden cross strategy
- Test autonomous research with a filter-and-evaluate prompt
- Let it run overnight on a complex optimization task
The future of algo trading isn’t just about writing better code—it’s about building AI research partners that evolve your strategies while you focus on higher-level decisions. And thanks to Google, that future is free to explore today.
