Copilot Context Window: What Fits and What Carries Over
A Copilot context window belongs to a particular product, client, and model. Learn how to check what the assistant can use and preserve work between conversations.
Updated 5 min read
A Copilot context window is the amount of information the active model can work with for a response. There is no single limit for everything called Copilot: first identify the product, the app where you use it, and the selected model.
That window is temporary working space, so it is a poor place to keep the only record of an important decision. Tools like fenbs keep project rules and verified progress outside the conversation, ready for a connected assistant to read when you begin again.
Which Copilot are you actually using?
Start with the name of the service, rather than a number found in a search result. A limit quoted for GitHub Copilot in an editor may tell you nothing useful about a Microsoft Copilot conversation. Also record whether you are asking a chat question or running a task that can read files and use tools.
| What to identify | Example | Why it matters |
|---|---|---|
| Product | GitHub Copilot or Microsoft Copilot | The shared name does not establish a shared context policy. |
| Client | VS Code, another editor, or a browser | The app assembles the material sent with your request. |
| Selected model | The choice shown for this conversation | The model and supported options affect the available working space. |
| Task material | Files, messages, references, and tool results | Your short question may be only part of the input. |
GitHub documents that available Copilot models depend on where you use it (opens in a new tab). Microsoft separately explains that Copilot Chat uses model selection and routing (opens in a new tab). Check the relevant documentation rather than transferring a model specification between those services.
What goes into the working space?
Think of the request as a packet assembled for the assistant. Your message belongs in that packet, alongside whatever history, instructions, files, and tool results the app includes. Tokens are the small pieces of text a model counts; a page count or file size is not a reliable substitute for that accounting.
A one-line question can therefore accompany a substantial packet. Say you ask why a checkout screen fails. The relevant error, a source file, an earlier attempted fix, and the project instructions may all matter more than the length of the question itself. A large attachment can add less value than one precise error message.
Do not assume that an indexed repository is all present at once. VS Code explains that its workspace index helps locate code without attaching every file (opens in a new tab). Explicit references help direct attention to known sources. Our guide to context engineering with GitHub Copilot covers preparing those inputs.
How do you check the limit that applies?
Use the current client and model documentation together. An advertised model maximum describes a capability, while your Copilot app determines which options it exposes. A number for a model used through another service is not proof that your selected Copilot conversation gets the same allowance.
- Confirm the product and client before comparing any documentation.
- Read the model selection shown for the conversation you are using.
- Check the client for context information and any supported context-size option.
- Consult the vendor page for that combination, particularly when an error appears.
- Keep request limits separate from account usage limits, which govern a different problem.
GitHub lists supported models and extended capabilities on its model reference page; use that page for changing availability and limits. Keep your own project notes focused on how to check the setting. A copied number in a permanent team instruction is easy to forget when the service changes.
For the general definition of the working space, read AI context windows; this page focuses on identifying the Copilot setting that makes that definition useful.
What carries into another conversation?
Separate files that still exist from conversation history that another chat may not receive. Saving a code change preserves that code. It does not necessarily preserve why the change was chosen, which alternatives were rejected, or the check you still need to run. Those details need an explicit home.
VS Code states that a new chat does not inherit other chats’ conversation history (opens in a new tab), even when chats share a workspace. That distinction explains why an assistant can see the implementation while missing the approval behind it. Verify the behavior of your particular client before relying on another transfer mechanism.
Save a short handoff: the goal, the current files or deliverables, approved constraints, completed checks, unanswered questions, and the next action. In fenbs, Where we left off gives the next connected assistant a place to start without assuming it has the previous conversation.
Keep the reason for the work outside Copilot
Add the project’s agreed rules, current task state, and next step to fenbs. A connected assistant can read those records at the start and save progress before stopping. Your project then has an inspectable starting point even when you change chats or AI apps.
Create a free accountFree for one person · No credit card · Works with Claude, ChatGPT, Cursor and more
Why can a larger window still miss the point?
Capacity and usefulness are different tests. A packet may fit while containing obsolete requirements, duplicated logs, or incompatible drafts. If the approved design is buried among several abandoned versions, increasing the space does not tell the assistant which one has authority.
Label the current source and its status. For example: “Use the approved checkout design; the attached earlier sketch is background only.” Ask the assistant to identify the decision that controls its next action. A plausible answer without that reference is a reason to clarify before it changes anything.
If the conversation hits an error, use the full context window recovery guide to preserve progress before restarting. For an ordinary Copilot session, keep the goal narrow and verify the few facts that determine whether its answer is useful.
How to do this with fenbs
- Create a free account. It is free for one person, with no credit card, so you can begin with one active project.
- Add the project and its current task. Record what is complete, which checks actually ran, and the next action in the task and Where we left off.
- Write approved constraints in Decisions and rules. Keep an unresolved proposal open; an assistant can record a person’s choice but cannot make the decision for them.
- Connect GitHub Copilot using the supported guide on Integrations. MCP is a standard connection that lets an AI app use an outside tool; follow the browser sign-in and grant the intended access.
- Ask the connected assistant to read the project context before working, then save progress before you stop. Start a fresh chat and check that it can name the correct next step.
fenbs does not enlarge Copilot’s context window or import its conversation history. It fits ongoing projects whose decisions and progress must survive the conversation; for a disposable question about one small file, an ordinary chat may be enough. Explore the context engineering hub when you need a broader workflow.