Testing Cursor AI IDE v1.0: First Look at the Background Agent Feature

The Launch of Cursor v1.0

Today I launched Cursor in the morning and it suggested updating to the latest version. I have auto-update enabled for all releases including beta versions, and I was surprised to see version 1.0 – which means it’s finally out of beta or MVP mode, despite so many developers having used it before.

Read further below (under the video). Please note if you’re going to watch the video that I’m very slow due to jetlag and and rainy morning so either listen at x2 speed or read summary / transcript 🙂

New Features in Version 1.0

After checking the news, I found several exciting updates in this version:

Jupyter Notebook Support

Cursor now supports Jupyter Notebooks and can create notebook cells within them. It currently works only with Sonnet, but other models will be added later.

BugBot Agent

There’s a new BugBot agent that can check your pull requests and search for bugs or errors. It can comment on problems and allow you to fix them with one button click.

Background Agent – The Game Changer

The most interesting feature is the Background Agent – an operator within your IDE that carries out tasks in background mode. This resonates with discussions from a recent Web Summit talk about the different phases of AI agents:

• Phase 1: Auto-completion – you write the first part of your code, press tab, and it completes the line
• Phase 2: Agentic assisted coding – the system creates files, works with your codebase and repository, but normally requires iterations with the human in the driving seat
• Phase 3: Background agents – you can set a task, leave it running overnight, and the system fully implements your application or goal, including self-criticism and QA

Other Notable Updates

• Context memory has been added (similar to ChatGPT) – Cursor should now remember preferences like “never switch models without my permission”
• MCP improvements – MCP servers can be added with one click, allowing interaction with various applications via Cursor

My Development Setup

I work with a Ethora Bots project sitting on my SSH server. Cursor, inheriting from Visual Studio Code, can work via SSH with remote servers using the SSH plugin.

My preferred workflow for experimental coding projects involves:

• Setting up a dev server on DigitalOcean or AWS instances
• Accessing it via SSH from Cursor directly
• Using a mono repository structure with multiple components (front-end, back-end, chatbots, documentation) in subfolders

This gives Cursor full context of the entire project, allowing it to reference backend code when working on frontend issues and vice versa.

Testing the Background Agent

The Task

I decided to test the Background Agent with a real project: converting my OpenAI bot from single-tenant to multi-tenant architecture. The current bot implementation works with one connection within one application context. I wanted it to handle multiple different applications simultaneously.

Using my Whisper transcription application, I dictated the requirements:

“The current OpenAI bot works with one connection and one application only. I want it to work with multiple different applications. App owners at the Ethora platform will create bot users in the admin panel. Our bot should work with multiple contexts – different user IDs, XMPP credentials, but ideally one copy serving many connections simultaneously.”

Preparing for the Test

Before using the Background Agent, I ensured my code was committed to Git using Cursor’s assistance. The system suggested commands and helped create proper commit messages – demonstrating Phase 2 agentic coding where the agent suggests actions but keeps the human in a supervisory role.

Background Agent Deep Dive

Setup and Security Considerations

The Background Agent runs in the cloud on Cursor’s AWS infrastructure. It:

• Clones your repo from GitHub
• Works in a separate branch
• Pushes results back to your repo
• Requires read/write privileges to your repository

Cursor warns about potential security issues:

• Infrastructure hasn’t been audited by third parties yet
• Possible prompt injection vulnerabilities
• Risk of malicious instructions being followed if found online
• Keys and credentials are encrypted at rest, but risks remain

The Agent’s Approach

The Background Agent analyzed my requirements and proposed a high-level architecture:

• Create a BotManager class holding a map of bot instance objects
• Each object manages its own XMPP connection and OpenAI context
• Support for adding/removing bots at runtime
• Event-driven patterns for scalability
• REST API for dynamic bot management

The agent worked autonomously without asking for confirmation on specific changes – unlike the typical interactive mode where every action requires approval.

Implementation Results

What the Agent Built

The Background Agent implemented:

• Multi-tenant OpenAI bot system
• Bot Manager and Bot Instance TypeScript services
• Memory service for conversation history management
• REST API endpoints for bot management:
  • POST /api/bots – Create new bot
  • GET /api/bots – List instances
  • DELETE /api/bots/:id – Remove instance
  • PUT /api/bots/:id – Update instance

GitHub Integration

Interestingly, the agent created a new branch called “cursor-create-bot-api-endpoint” and made commits under the “cursor-agent” GitHub user – a new way of working where the AI agent becomes a collaborator in your repository.

Testing and Debugging Challenges

Infrastructure Issues

During testing, my 2GB DigitalOcean server became overloaded and disconnected. I had to upgrade to 8GB memory at $48/month to handle the load from Cursor, SSH environment, and the VS Code extensions.

Context Loss Problems

I encountered typical Cursor context issues:

• The agent occasionally “forgot” what it was working on
• Configuration inconsistencies between background and foreground agents
• Problems reading from .env files correctly
• Hallucinated server addresses instead of using actual configuration

Mixed Results

While I did see evidence of bot instances connecting to our chat rooms during testing, various connectivity and configuration issues prevented full functionality. The problems seemed more related to Cursor’s general context management rather than the Background Agent feature itself.

Assessment and Future Potential

What Works

• Background Agent successfully completed the architectural planning and code generation
• Autonomous operation without constant human intervention
• GitHub integration with proper branching and commit management
• Comprehensive documentation and setup instructions generated

Areas for Improvement

• Context passing between background and foreground agents needs work
• Real-time progress updates would be helpful when the user is active
• Error handling and debugging capabilities could be enhanced
• Micro-management options for users who want to provide input during execution

The Verdict

The Background Agent represents a significant step toward Phase 3 AI coding – truly autonomous development. While there are still issues with context management and debugging, the core functionality works and shows great promise.

For developers willing to work through some rough edges, this feature offers a glimpse into the future of AI-assisted development where you can literally “set it and forget it” for complex coding tasks.

Conclusion

Cursor v1.0’s Background Agent is a genuinely useful update that moves us closer to fully autonomous AI development. Despite some limitations around context management and debugging, it successfully completed a complex multi-tenant architecture transformation that would have taken hours of manual work.

The ability to leave complex refactoring tasks running in the background while working on other projects represents a paradigm shift in how we approach software development. As these tools mature and context issues are resolved, we’re moving toward a future where AI agents become true development partners rather than just advanced autocomplete tools.

The Background Agent works, and while there are areas for improvement, it’s a significant step forward in AI-assisted coding capabilities.

FULL TRANSCRIPT:

So, today I launched Cursor in the morning and it suggested to update to the latest version
as I have this setting to auto-update to all the latest including beta releases and I was
surprised to see version 1.0,
which means finally it’s out of
beta or
MVP sort of mode,
despite so many developers having used it before.
So that was quite interesting.
Then I checked the news and
it says that there are a bunch of updates
in this version one.
First of all, it supports Jupyter Notebooks,
so it can now create notebooks like cells within them.
It works only with Sonnet at the moment,
but other models will be added later.
Another interesting update, there is a BugBot agent,
so it can check your pull requests
and search for bugs or errors in them.
It can also comment on all the problems and allow you to fix them with one button click.
Another interesting feature that I’d like to check out is Background Agent.
It’s an operator within your IDE which will carry out your tasks in background mode.
This resonates with what has been discussed
in one of the talks in Web Summit in Vancouver last week
regarding the different phases of AI agents.
So basically, phase one was auto-completion,
where you write first part of your line of code,
press tab and it completes this specific line.
Phase two, where we got to be like until recently
with all the web coding is agentic assisted coding,
which means that the system is able to create files,
work with your file system, work with your code base,
with your repository, create specific files,
modules, and solve specific tasks.
But normally it wouldn’t be equal to creating
a fully working and fully fledged application.
So it solves like specific tasks with,
through iterations with you in the driving seat.
And then, as was discussed, phase three would be where it’s the background agents where you could
literally set certain task, leave it in background overnight to work on your task,
Can the system fully implement your application
or your goal, completes the whole thing?
I assume including criticizing itself,
like evaluating different approaches, doing some QA.
So it’s not only just about like smaller implementation
or just a few files,
but it’s actually delivering the whole task
or whole like project being delivered in background.
In any case, it’s sort of asynchronous mode.
So you can leave it work and do something else.
So that’s, I assume what background agent is about,
but we are going to test and find out
if Cursor has gotten to this phase three,
yet. In other updates, the context memory has been added apparently, so like sort of similar as in
chat GPT. So as they say, if it’s presumably, if you sell like never ever switch models without
my permission or something like that,
the now cursor should be able to remember that finally.
All of us who have been using cursor
and done web coding with any other applications
have tried different things,
created read me’s rules,
copy pasted, done a lot of things,
but we’ve seen that in many cases,
cursor does lose the context of the project
or of your previous interactions.
So hopefully with this context memory improvement,
this is going to be solved.
Another update announced is MCP improvements.
So MCP can be added with one click
and you can interact with a lot of applications via cursor.
There is a list of MCP servers.
It’s sort of smallish so far,
but I guess you can add your own.
So yeah, those are interesting updates.
I’m going to try some of it in work.
So let me see if I could open one of my projects.
I’ll explain quickly.
So this is a Tora bots project,
which is sitting on my SSH server.
And Coursor obviously as sort of inheriting
from Visual Studio Code is able to work
via SSH with the remote server using SSH plugin. The way I organize things is
often like so I so the way I like to work with my sort of vibe coding
projects in the absence of a better term so when I need to experiment with
something quickly but it doesn’t always going to be something done correctly or
something that goes into production so I want to be able to quickly work with
something quickly tested.
If successful, commit things into repository,
share it with my team, but if not, just discard it.
So the structure that works for such purpose for me
is to set up things working as some sort of dev server
on, for example, a DigitalOcean instance or AWS instance.
and access it via SSH from cursor directly.
If there are multiple components such as front-end,
back-end, like chatbots or any other components,
including documentation, I like to put them all
into one sort of mono repo,
mono repository mega project in different sub folders
so that Coursera is able to have full context
of the whole project.
This is useful because for example,
when you’re working on the front end,
so that it is able to look up
if it’s solving sort of certain issues,
it’s able to look up your directory with your backend code
or with some alternative front-end implementation
and can sneak peek into those
and that helps in solving the problem.
And you can have your own monorepository GitHub
or Git repo for your experiments
and still keep nested repositories for specific modules,
which you can pull from your real,
from your coworkers, from your team,
from your official Git repos.
So that’s the setup that I use.
But in this case, it’s just like,
it’s a repository with the bots for our Torra platform,
which actually I have created in the first place,
but the team is, yeah, could also collaborate
in some cases. So what would be my next
steps? I want to do certain updates and I
mean let’s let’s see where is that
background. Oh actually I can see that
this background setting is available
right away create background agent it says so
okay
I mean what does what
happens if I just click here build research debug at a longer horizon
cloud for Opus Max
right so let’s try and pick certain
task which I need to
solve.
I have this bot called OpenAI bot which basically what it does it
implement OpenAI bot inside our chat application.
The developer or owner of this bot is supposed to put their own OpenAI API endpoint in.env file
and then the users or themselves will be able to chat with this bot in the chat room
and get it to you know answer questions or respond to anything
what I would like to do is to make this OpenAI bot to be multi-tenant and
be able to work with multiple connections
within the context of multiple applications.
So, by the way, can I dictate here?
No, I cannot.
I mean, I wanted to do like Andrei Karpathy kind of thing
and just talk.
So maybe I could launch my Whisper application
talk about what I want to achieve.
So,
okay, close this one.
(keyboard clicking)
Hi, so the current implementation of the OpenAI bot,
I assume works with one connection
and within the context of one application only.
I would like to make it able to work
with multiple different applications.
What I mean that app owners at eTorra platform
will create
their bot
users
and they will put the details of those bot users
somewhere in the like say admin panel.
And our bot, this application hosted at eTorra
our server should be able to work with multiple
contexts, so with multiple different connections.
So in one case, it will be application using one user ID
for their
OpenAI
bot.
In other case, it will be another application
using a different user ID
and different application prefix.
So XMPP, username and password will be different.
but we don’t want to spawn,
ideally we don’t want to spawn multiple copies of this
bot.
We want one copy of the bot to be able to serve
simultaneously many different such connections.
So there will be multiple connections
of our OpenAI chatbot using different XMPP credentials
into different chat rooms under different applications
within a Thora server.
How do we achieve that?
So, I mean, there is no transcription feature
in Coursera as far as I’m aware.
What I’ve done is I just launched
my Whisper transcription application
and I dictated this task.
(mouse clicking)
Before I go ahead and work with this background agent,
I just go, I’m going to double check that
the code is checked into Git,
just to make sure that if I break something
with this background agent,
that I will be able to roll back to the latest version.
And you will see here that I’m,
interacting with Cursor in a really non-technical way,
which anybody without deep technical background
can possibly do.
So I will just say,
I’m not going to type the git commands in terminal,
I could do that, but I’m just going to give this task
to Cursor.
so
(typing)
So it offers a command, git status,
and I just need to press this button
run.
It says no untrack, okay.
There are several changes that can be committed.
Linter, Redmi.
It suggests to do the,
to check the differences.
So this is what we were talking about.
This is sort of phase two.
The system, the agent is not just doing auto-completion,
it is actually proactively suggesting things but it still has me not maybe in the driving seat but
in some sort of controller or supervisor seat
double checking with me on every action so
which is probably a preferred way anyway for now
to avoid errors and breaking things.
So yeah, let’s check the differences.
It explains the changes that I or together with Cursor
we have done in the past, which could be useful
even for an experienced developer
if you abandon the project
And then you come back after a certain time,
like it’s happened with me,
I didn’t work with this for over like a few weeks.
So it explains what changes have been introduced
and not checked in into GitHub repository yet.
It asks, do you need help to commit?
Yes, sure, why not?
You can see it creates the
commit
command
along with the correct description
of what is being done.
(computer beeping)
This change
is
now live
in my remote
repository.
And
I will show that what’s
going on there.
(keyboard clicking)
You can see that
it has been updated just one minute ago.
This commit is live on github.com in our repository.
(keyboard
clacking)
Right, so back to our
Coursera development.
Now I want to, yeah, just go ahead
and use my transcription from Coursera.
Whisper, Whisper transcription.
I copy-paste the whole thing.
And let’s try this background agent and see how actually this works.
Correct some typos.
Background agent runs in the cloud.
applications, read our documentation.
Background agents currently clone your repo from GitHub.
They also
do their work in separate branch and push to your repo to make it easier for you to take over from them.
That means you need to grant read/write privileges to your repo and any dependent repos or submodules.
In the future we’ll also support other providers.
You can set up their environment yourself.
You’ll get an ID instance connected to the remote machine,
set up your machine, install development tools.
Okay,
so,
so interesting, it sounds like the background agent,
it actually will create an instance
on the core source servers in the AWS infrastructure.
It will
clone our repo.
It will do some work,
it will presumably do some pull requests
or push to our repo once done.
So, yeah.
It also runs all commands, which is obviously, I mean, I guess it’s straightforward.
It’s to be expected.
So instead of like just what just happens to me in the interactive mode, where I have
to approve all actions, it will just
auto-run, auto-approve everything on its own.
Coursera is warning us about possible security issues,
saying that infrastructure has not been audited
by third parties yet, that this might–
This whole setup might open doors
for certain kind of prompt injections.
So for example, if agent decides to
find instructions in Google
and finds a page with malicious instructions,
it might follow those instructions
and exfiltrate your code or do something else.
Obviously your keys and other things.
I mean, Coursera says that it’s encrypted at rest,
but yeah, those are all considerations
we should take into account.
Right, so let’s
see what our agent has come up with.
So yeah, it says, you want to evolve your OpenAI
single tenant to a multi-tenant architecture all within a single running
process. Well I don’t know if it’s a single running process, multi-processes
but yeah that’s what I want. Here’s a high-level plan store multiple bot
credentials
process many connections.
Rough structure.
So it suggests to create a class, BotManager,
and that it will hold the map of bot instance objects.
Each object will manage its own XMPP connection,
so our chat protocol connection
and
open AI context.
The manager can start, stop, reload instances as needed.
Message routing will keep context separate,
clearly within this Bolt instance infrastructure.
Adding or removing bots at run time,
yes, we would like to do that.
Periodically pull the config source for changes.
Add or remove instances as needed, scaling considerations.
Okay, moderate
numbers,
tends to low hundreds will be fine one process,
but for very large scale,
we would want to shard across processes or containers.
Totally
fine,
let’s move on with tens to all hundreds
and then we can improve this.
XMPP.js, the library that we use for our chat protocol
supports multiple clients in one process.
I think
wait,
even driven patterns sounds good.
Summary steps, change
config, refactor code,
is isolate state, optional dynamic reload.
Would you like a code example for the bot manager
and both instance pattern,
or do you want to discuss how to migrate
your current code to this architecture?
Well, I don’t really want to discuss or some code examples.
I want this
background
agent to do the whole,
to build the whole
thing at
least.
I mean, that’s our expectations,
expectation for this experimental thing.
So let’s launch
Whisper and
do a new dictation.
(keyboard
clacking)
Regarding the configuration and bot credentials,
I think these credentials will be coming
from our Etorah backend.
So the app owners will be creating these bots
in the admin panel and assigning them to chats.
So our bot application should have
some sort of API endpoint, I assume,
or it would read from certain feed
where our backend application will be assigned
sending instructions with
logging and password, XMPP logging and password of
our bots along with
XMPP JID for the chat rooms
these bots should join.
So I guess there would be multiple API endpoints for our bot.
One endpoint should allow to
create
or remove bot instances,
each with its own XMPP credentials
and each with its own
XMPP JAD for chat room.
Yeah, I guess that’s actually it.
So our API endpoint should allow to create or remove
bot instances.
To create a bot instance, we should
accept the following parameters.
First, XMPP username for our bot.
Second, XMPP password for our bot.
Third, first name for our bot.
Second, last name for our bot.
Fourth, sorry, I mean,
and next one is app JAD,
sorry, chatroom JAD for our bot to join.
And another one will be a string parameter
with a specific prompt allowing to set
specific local context for our bot
to be passed to the OpenAI LLM.
That’s it.
So let’s implement that.
And let’s create either a.env or a certain sample or test
config or JSON file where instead of the API endpoint,
we accept these parameters locally for testing purposes.
So we can start
from this first.
Before implementing our API endpoint,
or in parallel to doing that, let’s test our approach
by creating a local configuration file where
we can set up, we manually enter bot XMPP login,
bot XMPP password, bot first name, bot last name,
the JAD of the chatroom for the bot to join,
and the prompt string to be used.
be used for specific bot instance.
Transcribe recording.
(sniffling)
Copy paste the whole thing into the cursor instructions.
Yes, enable. Why do I have to press this again?
Okay, setup GitHub Connect.
Right.
Let me see.
(door creaking)
So I can see the background agent is still working.
And I assume the idea is just I just work on something else in the meanwhile
(mouse clicking)
It would be good if for such cases
where the human operator, the user is active
in the IDE that it would provide
some updates in regards to what exactly
the background agent is doing
currently.
And maybe add some UI to manage,
like to be able to stop or clarify the task.
I guess those are some of the things
that would be happening in future.
but obviously for the purpose of just leaving this working and going away or going to bed
And this sort of interaction is enough.
So I’m just going to work on something else and come back to this when it signals me,
Hopefully to review the update
(clicking)
(clicking)
(clicking)
(clicking)
[tapping]
So I assume what might be happening now is that this background AI agent could be stuck
in some sort of debug loop like Coursera tends to do normally.
so it might be lacking certain information.
In some cases, it is able to resolve,
figure out things on its own.
In many cases, it’s not.
It would probably benefit and could be able
to work much faster if it had the chance
to ask me questions.
So I’m just like, okay, something is finished, looks like.
But yeah, I was just thinking aloud.
So for example, like maybe an improvement
or this interface could be an optional micro-management
or transactional interaction
where the background agent assumes
that it runs on its own,
and it assumes that the user is not there
to be able to respond.
But just in case the user is there,
it could provide micro mini updates
and as to what it’s doing,
and more ask questions.
And if the user is available,
If the user is around, the human user can provide inputs
or additional context or help out,
but otherwise it doesn’t wait.
So it doesn’t wait for the responses.
It continues on its own.
However, there is this option for the user
to break the loop in cases when it’s not needed.
However, we see that our background AI agent is showing us the green tick “finished” check
checkmark.
So, I mean, what am I supposed to do now?
Review changes or open background agent?
Let’s click open.
Okay, so
what’s like, what is being offered?
It says, I
implemented a
multi-tenant OpenAI bot system
that can manage multiple bot instances simultaneously.
Bot manager, bot instance, TypeScript, services,
memory service, conversation history management,
REST API for dynamic bot management.
Per instance settings.
Okay, REST API points, API boards, create new boards,
get list of instances, delete, remove instance,
put update instance,
makes sense so
far.
Okay, there is this button which says add follow up.
I don’t know what that means.
okay
Okay, so Coursera
has in its typical manner has added
description of the architecture,
considerations for scaling and security which is pretty much boilerplate
health checks package
Remedy.
How a Thor backend will use this?
App owner creates bot user in
a Thor admin panel.
A Thor backend calls POST API bots,
connects to XMPP, joins specified site chatroom,
users can interact with bot by mentioning it.
Update bot
settings via Puts, Delete, Get, Monitor Status.
Next steps to start, install dependencies,
configure environment, run in development, enable API.
All right,
so how do I test this?
I mean, it
has done
the changes.
I can see like in,
unlike in the typical inter,
transactional interactive agentic mode,
this background agent didn’t ask me
to confirm specific changes or creation of files,
adding new, removing things.
It just has done all those things without asking,
which I assume is what to be expected.
Now, I want to test this.
So, how do I test this?
I can provide inputs for
post API
ports
planning next moves
What I think I should have done probably is I should have created a new folder for this
version.
So I would keep the old OpenAI bot implementation, which I have done as a simple implementation
because maybe some of the users or developers looking at it
would prefer a simple implementation
just for the specific custom chatbot,
and they would not need this multi-tenant implementation
with API, which Coursera for me,
Cloud are implementing for me right now.
However,
right now, we already kind of gone
ahead
with this.
So let’s keep working on this.
So my
previous implementation
will be updated
with this new, more advanced version.
If I want to restore or copy, reinstate my previous
version,
I
can always go to GitHub and find changes there,
find the previous version there.
so by the way interesting let me show this
let me show this
(dog
barking)
So what I’m showing right now is
I have just checked my GitHub repository
and there are no changes in the main branch.
However, when I click on the branches,
I can see that new has branch has been created
called cursor create bot API endpoint
and something blah, blah.
And in this one, there are actually changes
in the packages 11 minutes ago.
So during the process for now,
background agent has been working
and you can see cursor agent as a GitHub user,
actually contributing there, which is interesting.
So previously you could use cursor
and author your changes yourself,
but now it’s done under cursor agent user.
need to think about implications of that.
Anyway, so…
Okay, so in the packages it has created,
we used to have a bot core package,
but now we have bots open AI bot package created there.
going back to cursor
So
one
of the issues is, I mean, it’s supposed to add my OpenAI API key into the.env file
and then run the bot.
However, obviously being a background agent, it tries to run things without asking.
So I didn’t have a chance to add my OpenAI key yet.
So that would be one of those hiccups, working in this mode.
so while it’s running I will try and
Fix that issue with the OpenAI key.
However, another
thing to note here is that on the left we have the menu which gives us
options, create pull request, check out locally,
or imports to local chat.
So I could create a pull request,
I assume, by pressing this button to my main branch.
And then I could, as a manager of the repository,
import that pull, approve that pull request
and that would then be similar to working
with another developer, in this case,
cursor background agent, creating the whole thing.
(clicking)
I’m trying to find that.env file.
Okay, I guess I found it.
So I found the
.env example file which makes sense.
So I can choose to enable or disable my API endpoints.
And if I enable API, then I’m supposed
to enable to add a safe secret key for the API.
So presumably for our backends to be able to call
this bot application to be able to post those API requests.
And I’m supposed to add OpenAI key here.
I need to copy this.
Edit.
(clicking)
Just need to clean up a bunch of screenshots I got there.
okay so it’s it’s doing some work in parallel
it’s creating shell and
Python test
script so I’m able to do some tests the
way I wanted
Now I’m going to…
room.
(keyboard clicking)
(clicking)
I’m just trying to figure out how to duplicate this
dot env dot example file
so I can create the proper dot env file.
Otherwise I’m doing something wrong
or either I’m doing something wrong
or it doesn’t work this way in the cloud instance
for this specific agent.
Alright, so what am I doing wrong?
File.
Can we create a new file?
File, new, text file.
(mouse clicking)
(mouse clicking)
Yeah, I guess I should,
so if we consider this instance to be a server instance, like
GitHub checked a repository instance,
like then I should create a pull request
Presumably
I should not create.env file here, and then I should create.env file in my local
Being my initial SSH server in my dev server. I should do that there, so let’s try doing that
I mean I have this option, so I’ll do pull request
I have been redirected to GitHub.
In window.
Okay, let’s create this pull request.
All right, now we can merge this
pull request.
Let’s do that.
Why not?
YOLO.
yellow
five minutes ago
we can see updates in the main branch
now go back
to Coursor
shall
we do checkout locally
Now here I should be able to edit my local.env file.
yeah I had my.env there before but it’s like
it’s a different format it’s
I’ll rename that to.old
Now I’m just copying from my old.env file
credentials which I used before into my new.env file like my bot.jd so my bot.login
my room.jd so my room address my bot password
and
(keyboard clicking)
I need to write open area key as well.
Okay, so
now that is done,
I’m going to try launching this one of those test scripts.
Let’s try doing that.
So the background engine has created two test scripts
for us, one in Python, one in Bash.
or we can also test manually with curl
let’s try launching one of those scripts
packages bots
(keyboard clicking)
Okay, the script expects our API to be running locally
with the test secret key.
so
Yeah, this doesn’t make sense for me
because it has created,
it’s, I
assume it
will try to create bots
with these credentials which are not from our.env
file.
So…
(clicking)
Now I’m going to make some changes because this won’t work and I need a cursor to be
able to
do this
(clicking)
(keyboard clicking)
(clicking)
Right, so I’ve just done some changes to make sure that OpenAI key is included
configuration files and I will ask the agent to
to update this example with my real credentials for XMPP username password
and room room ID
So now it’s glitching slightly, so it says that I cannot find those test files.
Well, I mean, test files are named without the bot in the name, so Coursera has just
lost a bit of its own context here and I just wanted it to update the
I wanted it to update curl with
with the correct credentials but
I’ll just do it myself in terminal I
guess
So I will use from my configuration
my
credentials
and test this CPU.
(typing)
So I can
post this curl request in the terminal.
(mouse clicking)
Yeah, I should probably do that.
I mean, I was going to say that I could also throw it
to the agent and ask the agent to do this
so the agent can immediately see the response.
I mean, either way it works.
The application running on port 3000 is unavailable.
Yeah, I guess the application is probably not running.
So I mean, anyway,
let’s get the agents to do the work.
It will see that the application is not running
and we’ll sort it out.
Ok, I mean, that works too.
Run.
(keyboard clacking)
(notification
chimes)
(keyboard clacking)
(computer mouse clicking)
So again,
the cursor
has lost a bit of context here.
It was trying to find server Python or something,
so it forgot what it was doing before.
Clearly the previous context of the agent
has been lost at least partially.
And I’m not sure if there was some sort of context
passing between the background agent
and our foreground agent.
(clicking)
Yeah, I don’t know what he’s doing right
now.
So I mean…
Was it waiting for me to click accept?
(typing)
(sigh
(computer chimes)
We’ve lost connection to our SSH server,
So probably it was overloaded or something.
Something has caused our server to
either run out of memory or simply
reboot or something like that.
So.
(keyboard clicking)
[typing]
What I’m trying to do now is log into DigitalOcean.
Yes, so the issue there is this server is relatively small, so it has 2GB of memory
and it might be not enough to run all the environment
with the SSH environment with cursor and
everything.
So, I mean, as I understand that cursor is running
the background agent on its
own AWS
infrastructure,
but my server still needs to maintain
The memory, the context, the Visual Studio,
or whatever, VS Code extensions.
And
so I’m going to
upsize it to eight gigabytes, I guess.
Yeah.
so I will turn off
I will resize.
It’s resizing now so I’m just waiting for that to complete.
Droplet has been resized, so I’ll turn it on.
So yeah, I
increased from the basic 8 or 12$ per month 2GB memory CPU to premium Intel
8 gigabyte and two virtual CPUs at 48 dollars per month.
This should solve the problem for now.
Reconnecting.
All right, I need to enter my password now.
(clicking)
Yeah.
Let’s try and resume our debugging or our testing.
I guess I’ll just try and
curl.
I don’t know if we need all that so I’ll just…
[ Typing Sounds ]
So it tries to create.env file which is already there, so some sort of typical again cursor problems.
(keyboard clacking)
You can Australia’s
It found some errors, I shouldn’t have accepted all the previous changes, but I pressed that
button.
I said earlier that I didn’t want those updates, but yeah, I mean, just clicked on “accept
all” and I guess that’s what happened.
Let’s just go ahead with this white flow and try and use this suggestion.
Yeah.
(phone chimes)
(door
creaking)
(phone chimes)
[ Noise ]
(phone chimes)
Okay, so I just had to go through a bunch of debugging things because the bot, I mean
the cursor has tried to launch the whole
thing, including another
bot which we didn’t need
here prisoner dilemma bot which I created before and following the fixes that cursor has introduced
it needed to do some
additional
fixes so now it’s done and it seems that our server is running
some errors here also i’m not sure if it’s using the correct openai key but
but yeah i mean something is we got some progress some initial progress so i’ll just give this
I will give this feedback.
I don’t know if it’s just me or is it for everybody that cursor is not able to properly
seamlessly read from its own terminal windows and I have to copy paste things from there
Okay, yeah, I can see that the server that
it’s trying to use is completely wrong
address so I’ll have to tell it
I don’t know where it’s…
yeah, it just…
just hallucinated the server address, it should have taken it from the envu file
file.
It is not able to read.env file.
Right.
One second, I’ll just sort this out.
[ Typing Sounds ]
(phone notification)
Okay, something is wrong.
It’s not able to connect to our XMPP server.
I don’t know
why.
The server is working.
Actually, it checked right now and yeah, it seems that…
[BEEPS]
It seems that during this tests,
I actually was able to, yeah, to have one of the,
you know, bot instances connect to our chatroom here.
It was like 20 minutes ago.
But yeah, obviously there are some issues right now
with the connection, so could
be like some sort
of typical
cursor issues with losing context,
trying to do things we didn’t actually need to do
and yeah, updating something.
So I’ll need to spend some more time and debug it.
So
I’m a bit kind of slow this morning,
being jet lagged and everything.
So I’ll probably just make a break right now.
I need to, you know, get more focused
and spend time on this to solve this problem.
We have tried this background feature,
background agent feature from Cursor. It works. We can obviously see some
limitations. It would be either limitations that I don’t know how to
fully and properly use Coursera and all the tools available
or, and/or the issues from Coursera itself
that in some cases it loses context as before.
I’m not convinced the context is being passed correctly
from the background agent to our foreground agent.
and if it does pass,
we have the typical cursor foreground agent issues
with potentially losing context and other bits.
I don’t know if it’s down to like auto being selected here
because,
but yeah, I’ve seen
a number of this before
and other users are complaining on Reddit
time to time about these issues.
So it’s probably to be expected.
So
hopefully Cursor can
fix the context issues,
especially that in the today’s updates,
it has been announced that context memory
or long-term memory is improved.
So I don’t see a lot of improvement there at the
moment,
but hopefully it does happen.
So yeah, I think I’m going to take a break
right now,
but I will resume later.
And I think actually,
yeah, this
is useful.
This is useful update.
The background agent works.
the issues that we’re experiencing are more to do
with the context models foreground agent.
Yeah, things there.
Taking a break,
put this on pause
and we’ll come back later to finalize this task.