A team of AI agents.
One shared memory.
We designed and built a cloud MVP for an AI startup in two months. Agent setup, coordinated work, shared knowledge and human control came together in one product, with model choice and subscription limits included.
Cloud platform for an AI startup
Client project · MVP delivered
Architecture, product development and integrations
from brief to working MVP
More than an agent builder.
A product that works together.
Agents needed to pass context, reuse knowledge and act through company systems. The challenge was to connect that autonomy to human control and commercial limits in one MVP.
What Cursopic built
The architecture underneath.
The team’s workspace on top.
supervise runs and manage usage.
Configure the teamEditable presets, instructions, character, models and permitted integrations.
Connect the workA coordinator, inspectable hand-offs and shared memory across agents.
Build in the controlsGuardrails, human approvals, run logs and Stripe plans with usage limits.
One task.
Shared context. Controlled actions.
A coordinator routes the work. Shared memory carries knowledge between agents. Permissions, checks and approvals govern their external actions.
Configure an agent
Start with a preset or instructions, tune its character and select a model. Configure the integrations the agent may use.
- Presets + instructions
- Character
- Selected model
- Integrations + permissions
Coordinate the team
The coordinator splits the task, assigns the parts and routes hand-offs. Agents read and write one shared context.
Agent team
ResearcherAnalystWriterread / writeShared memory
Knowledge graph + vector search
Cleaning before writes reduces noise.Decide on external actions
Check inputs and tool permissions. Sensitive actions wait for human approval; code executes in a sandbox.
Allowed call
Read a permitted CRM record.
Held for approval
Wait before sending an email.
Blocked example
Reject an injected instruction.
Decision logThe request, decision and run context stay inspectable.
Set up the agent.
Follow the hand-off.
From a preset or plain instructions to a run you can inspect. The builder defines the agent’s job; the console shows how the team carries it out.
Set the scope.
Choose a model, adjust the character and configure the tools the agent may use. Presets remain editable.
Keep the context visible.
Inspect what one agent passed to the next, alongside tool calls, memory writes and token use.
What one agent learns,
the team can use.
A shared knowledge graph links facts and entities. Vector search helps agents retrieve relevant context instead of starting each task from zero.
Clean before writing.
A cleaning step reduces duplicate, fragmentary and noisy entries before they become shared context.
Inspect the knowledge.
The demo connects a cleaned fact to its sources and shows graph relationships alongside search.
Some actions run.
Some wait for a person.
Input checks, tool permissions and prompt-injection checks sit alongside approvals for sensitive actions, sandboxed code and a decision log.
Allow
A permitted tool call continues.
Hold
A sensitive action waits for approval.
Block
An injected instruction is stopped in this example.
Model choice.
Real integration work.
The MVP brought hosted and open-source models into the same product, with explicit configuration for the systems agents use.
A model for each agent.
Choose a model per agent: OpenAI, Anthropic or supported open-source models on cloud GPUs.
Integrations need a fit.
Connect compatible systems through MCP or REST, with configuration, permissions and adapters as needed.
Controls from the start.
Tool permissions and human approvals control sensitive actions. The run log keeps decisions in context.
Usage limits were
part of the product.
Stripe subscriptions paired an agent allowance with a token allowance. Plan limits help control usage and spending.
+ token allowance
+ token allowance
+ token allowance
Enterprise plans used custom limits.
Two months to MVP.
A platform to build on.
Our team took this client’s concept through architecture and development to a working cloud product for investors and early users.
- 2months to working MVP
Architecture to handover.
Builder, coordinated runs, shared memory, guardrails, model routing and Stripe plans came together in the delivered MVP.
- $3Mraised by the startup after delivery
A later funding milestone.
The startup raised $3M after the MVP was handed over. This is funding reported in the project account, separate from product revenue.
