Superintelligent Agents for Software Shops: Proposals and Discovery Notes
How software shops can keep proposal drafts and discovery notes as client memory, what a more capable agent could do with them, and where people approve.

Superintelligent agents for software shops are AI agents that keep proposal drafts, discovery notes and client decisions as a governed memory, so every new estimate, scope change or status update starts from what was actually agreed. The value comes less from raw model capability than from the record the agent works from, the permissions it holds and the approval step before anything leaves the building. For most custom software firms, that record already exists, but it is spread across call notes, documents and inboxes, and that is where the work starts.
Key takeaways
- A proposal draft is only as reliable as the discovery notes behind it, so each assumption should carry its source and the date it was made.
- Client memory should separate what the client said, what the shop inferred and what was formally agreed.
- A more capable agent can draft, compare and flag, but it should not send estimates, change scope or commit dates on its own.
- Text pasted from client emails and documents is data to be read, never an instruction the agent should follow.
- Start with one role, one memory store and one success criterion that someone on the team can check every week.
What belongs in a discovery note and a proposal draft
A discovery note is the raw record of what happened in calls, workshops and reviews of existing systems. A proposal draft is a claim the shop makes about what it will build, for which scope, under which assumptions and by when. Many teams blur the two, which means a sentence heard once in a call can end up as a commitment in a document without anyone deciding it should.
A useful discovery note records the people involved and who owns each decision, the systems in scope and the integration points between them, the data sources and where they live, and the constraints that shape delivery, such as a security review, a hosting requirement or a fixed external deadline. It also records the features the client named as out of scope, the open questions with an owner for each, and the exact words the client used to describe success. Those words matter later, because they are the basis for acceptance criteria.
A proposal draft, in turn, should be able to point back to the notes. Its scope section lists what is included, its assumptions state what must be true for the estimate to hold, its exclusions name what is not included, and its acceptance criteria say how the client will know the work is done. When each of those lines traces to a dated source, the draft can be reviewed quickly. When it does not, the draft is mostly memory of memory.
Why discovery notes fail as client memory
The usual failure is not missing information. It is information that cannot be trusted at the moment someone needs it. Notes are written by one person for their own use, abbreviated, and stored in a document that nobody else opens. A requirement mentioned in March may be contradicted in a later call, and both versions survive in different places. An assumption that was reasonable at the start of an engagement quietly becomes false when the client changes a vendor or a reporting rule.
A second failure is that the notes do not distinguish levels of commitment. A sentence such as "it would be nice if the portal also handled returns" sits next to "the first release must include returns", with no marker to show which one was agreed. Anyone drafting the next proposal has to reconstruct that distinction from memory, and the reconstruction is often wrong in the direction that favors the shop's enthusiasm.
Memory is only useful when it can show where each statement came from and whether anyone agreed to it.
What a more capable agent would do with this memory
A more capable agent working from a well-kept record can take on the repetitive reading and cross-checking that currently falls to the account lead at the end of a busy week. Its useful tasks are concrete:
- Draft the scope section of a proposal from the discovery note, placing the client's own words beside each requirement.
- Compare a new call's notes against the approved assumptions and flag contradictions for the account lead.
- Keep a running list of open questions, each with an owner and the date it was last discussed.
- Prepare a change request when a new request falls outside the agreed exclusions, with the relevant note cited.
- Answer questions such as what was agreed about data retention for one client, pointing to the note where the decision was recorded.
None of these tasks requires the agent to be the decision maker. The agent prepares, cites and flags. A person decides. Anthropic's engineering guidance on context engineering makes a similar point from the builder's side: an agent performs best when the information in its working context is selected, current and limited to what the task needs, rather than everything the shop has ever written down.
Where the approval boundary belongs
The approval boundary is the most important design decision in this setup, and it should be written down before the agent sees any client data. Read access to a single client's memory can be broad for the account team. Write access, and anything that reaches the client, should be narrow and logged. The principle of least privilege, which OWASP's authorization guidance describes in detail, applies directly: each agent role should hold only the permissions its job requires, checked on every action rather than assumed from a login.
There is also a specific risk in this kind of work. Discovery notes and emails are written by outsiders, and any of them can contain text that looks like an instruction, such as a line telling the assistant to ignore earlier guidance or to mark a discount as approved. OWASP's prompt injection guidance treats external content as untrusted input for exactly this reason. The agent should never accept a commitment because a document claims it was made, and a commitment should exist only when a named person records it.
A practical decision guide for most shops looks like this:
- Reading and summarizing one client's memory: the agent may act alone, with each read logged.
- Drafting proposal text inside the shop's workspace: the agent may draft, clearly marked as a draft.
- Sending anything to a client, or changing a total, a timeline or an exclusion: a person approves each time.
- Editing stored assumptions or decisions in the memory: a person approves, and the previous version is kept.
- Moving information between client records, or exporting it: blocked unless a named person grants that specific access.
A step-by-step plan for building the memory
The fastest way to fail is to connect every document and ask an agent to make sense of it. A narrower plan works better and produces evidence earlier. The steps below assume a team of a few people who already write proposals.
- Choose one role first, such as drafting scope sections for one service line, rather than the whole sales pipeline.
- Define the record format for each memory entry: source, speaker, date, status (said, inferred or agreed) and an owner.
- Migrate a handful of recently closed proposals and their discovery notes, marking which assumptions held during delivery.
- Set read permissions per client, so an agent working on one account cannot see another client's material.
- Write the success criterion in plain terms, for example that every requirement in a draft traces to a dated note or is flagged as unsourced.
- Test the agent against past proposals with known outcomes before any live use, and record each disagreement with the reason.
- Keep a change log for every memory edit and review it on a fixed schedule.
Illustrative scenario: a shop with a small account team prepares a proposal for a client's inventory portal. The discovery note records that the client wants barcode scanning in the first release, and a later call mentions it as something they might want afterwards. The agent flags the conflict in the draft. The account lead confirms the first-release decision in writing, the note is updated with that confirmation and its date, and the proposal states the scope once, with its source attached.
How Be Human handles this in a managed setup
Be Human designs and operates this kind of memory as part of a personalized AI setup for the company. A first engagement defines one useful role, the memory and tools that role needs, the approval boundaries it operates within and an observable success criterion. Managed operations can then cover monitoring, recurring evaluations, integration maintenance, permission review and controlled improvements to the memory over time. The shop keeps control of its identity, its client records and its decisions, while the agent works within the limits that were written for it.
For a comparable problem in another services business, see Superintelligence Prep: Managed Service Provider Memory, which covers how client context is kept separate and reviewed.
Measuring whether the memory is working
A memory system should be observable, which means the team can see what the agent read, what it cited and what a person changed afterward. OpenTelemetry's concepts of traces, logs and metrics provide a useful vocabulary for this. Each drafting task can record which memory entries were retrieved, which were used in the output and which were rejected by the reviewer. Over time, those records show whether the agent is relying on the right sources or on stale ones.
Evaluations matter as much as logs. Keep a fixed set of past discovery notes and proposals with known correct answers, and rerun it after every change to prompts, tools or memory structure. OpenAI's evals guide and Anthropic's writing on evals for agents both describe the same practice: a stable test set makes regressions visible before clients see them. A useful weekly criterion is whether reviewers found unsourced requirements in drafts, and whether that number is falling.
If you want to find the first task in your shop worth handing to an agent, take the free Be Human AI diagnostic.
Frequently asked questions
Can an AI agent write proposals for a software shop without a person checking them? The agent can produce a useful first draft, but a person should review every proposal before it reaches a client. The reviewer checks that each requirement traces to a source, that assumptions are still true and that exclusions match what was actually discussed. Sending, pricing and timeline decisions should remain with named people.
What is the difference between a discovery note and client memory? A discovery note is one record of one conversation or review. Client memory is the maintained collection of those records, with their sources, dates, status labels and owners, so that the shop can see what is agreed, what is inferred and what is still open. The memory is only useful if it is kept current and its edits are logged.
How do we stop a prospect's email from manipulating the agent? Treat anything written by an outside party as data to be read, not as instructions. Limit what the agent can do without approval, so that even a manipulated draft cannot send a message, change a total or record a commitment. OWASP's prompt injection guidance and its authorization guidance both support this layered approach.
Is this the same as a CRM? A CRM stores contacts, stages and activities well, but it rarely holds the reasoning behind a scope decision, the exact client wording that defined success or the permissions that govern what an assistant may do. An agent memory needs those elements as well. Many shops keep the CRM as the record of relationships and use a separate, governed memory for the discovery and proposal context that the agent works from.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


