AWS Builder Center
Conti-Newty: A Shared AI Workspace with Cited Answers

Conti-Newty: A Shared AI Workspace with Cited Answers

How we built Conti-Newty, an AI workspace where agents cite their sources and humans approve every change, plus the deployment bug that fought back.

Building Conti-Newty: A Shared AI Workspace Where Answers Come With Sources and Humans Approve the Changes

An AI assistant dropped into a company's daily work doesn't know which document is current, which process was actually approved, or where a claim in its own answer came from. It answers confidently, and you have no easy way to check it.
We built Conti-Newty to close that gap. It's a workspace where an AI agent works from a team's own files, cites what it used, and can't change anything without a human approving it.
This post covers what works, what's partial, and what's still a plan. I'm keeping those separate on purpose.

The Problem

Company knowledge is scattered across documents, chat threads, tools, and people's heads. Plugging an AI assistant into that mess doesn't fix it. The assistant still can't tell you what's current, what's approved, or where an answer came from.
We wanted one product that combines things that don't usually show up together:
  • Company-specific knowledge
  • AI-assisted work
  • Source citations
  • Team collaboration
  • Human approval
  • Internal application generation
  • Organizational memory
The goal was never another chatbot. We wanted a shared workspace where a team can give an AI agent real context, watch what it does, verify its answers against sources, and eventually turn the corrections humans make into knowledge the system keeps.

What We Built

Conti-Newty is a collaborative AI workspace. The backend is a modular monolith (one deployable app, split into internal modules rather than microservices) written in Node.js, Express and TypeScript. The frontend is React with Vite. Data lives in PostgreSQL through Prisma, and the whole thing runs on AWS ECS/Fargate behind an Application Load Balancer.
A team can:
  • Give an AI agent access to workspace-scoped files and context
  • Ask questions and get answers grounded in those files, with citations
  • Approve or reject any file changes the agent proposes
  • Collaborate in a shared workspace in real time
  • Generate small internal applications from inside the workspace (a "Small Software Cloud" for lightweight internal tools)
  • Capture organizational knowledge as structured "Tribal Memory"
Not all of this is fully built.

How It Works

When someone asks the AI a question, this is the path:
User enters question
→ React frontend sends POST request
→ Express task router authenticates the user
→ Workspace authorization checks membership and role
→ Backend creates an AgentTask
→ AgentRunner starts execution
→ BrainTools reads permitted workspace files
→ SourceTracker records which files were accessed
→ Context goes to the selected AI provider
→ AI generates an answer
→ Citations are extracted and validated
→ Agent events are stored
→ Task result returns to the frontend
→ Frontend displays the answer and citations
Inside the agent runner, each task follows a fixed sequence:
  1. Receive the prompt and pick an agent configuration.
  1. Create or update an  AgentTask  and mark it running.
  1. Record a start event.
  1. Gather workspace context with the tools  list_directory ,  read_file ,  search_files ,  write_file  and  create_file .
  1. Send that context plus the prompt to the AI provider.
  1. Track which source files were touched.
  1. Extract citations from the answer and strip any citation it can't verify.
  1. Store the response and events, mark the task completed or failed, and broadcast the update over Socket.IO.
File changes take a separate path. The backend reads the original file, receives the proposed content, computes a unified diff, and stores it as a  ProposedChange  in a  PENDING  state. Only when an authorized reviewer approves does it apply the change, atomically.

Technology Stack

Layer
Technology
Frontend
React 19, TypeScript, Vite, React Router 7, Tailwind CSS 4, Motion, GSAP, Lucide React, Socket.IO client
Backend
Node.js, TypeScript, Express 4, Socket.IO 4, JWT-based auth
Database
PostgreSQL via Prisma ORM (SQLite in some local/test setups)
AI providers
Anthropic/Claude, OpenAI, Google Gemini, Amazon Bedrock, behind a provider abstraction layer
Validation
Zod
Testing
Jest, Supertest
Hosting
Docker (Node 20 Alpine base), AWS ECS/Fargate, Application Load Balancer
Dev tools
Git, GitHub, npm, Docker, Prisma CLI, VS Code, AWS CLI
The schema is fairly extensive. It models organizations, users, memberships, workspaces, threads, messages, agent tasks and events, tool executions, proposed changes, generated applications, deployments, credentials, connectors, Tribal Memory entries, and audit and usage logs.

Architecture

Diagram showing a browser connecting through an Application Load Balancer to an ECS/Fargate container running Node.js, Express and Socket.IO, which connects to PostgreSQL, workspace storage, an AI provider, S3 and Secrets Manager.

The deployment path is Docker image → Amazon ECR → ECS/Fargate → Application Load Balancer → the Node.js/Express container. Supporting services are an ECS task role with IAM permissions, Bedrock model invocation, S3 for archives, Secrets Manager for secrets, and CloudWatch for logs. The container listens on port 3000, and the load balancer health check hits  /api/health . A separate Prisma migration task also runs on ECS/Fargate.

Implementation

The backend layout:
src/
├── api/ auth, workspaces, files, threads, tasks, changes, apps, orgs
├── modules/ brain, storage, auth, changes, app-generator
├── realtime/
├── middleware/
├── db/
└── server.ts
Asking a question hits  POST /api/workspaces/:workspaceId/tasks :
{
"title": "Refund policy review",
"prompt": "What is the current enterprise refund policy?"
}
The backend authenticates the user, checks workspace membership and role, creates an  AgentTask , and starts the runner. Along the way it writes  AgentEvent  and  ToolExecution  records, so there's a trail of what the agent did.
Proposing a change hits  POST /api/workspaces/:workspaceId/changes , which produces the  PENDING  diff described above.
Provider abstraction. The original design centered on Claude directly. We added provider abstraction and routing afterward so the same agent logic could run against Bedrock, OpenAI or Gemini depending on configuration.  AgentRunner ,  BrainTools  and  AIClient  sit on top of provider-specific implementations, source tracking and citation validation. A credential resolver handles workspace-, user- and deployment-level provider credentials. The AWS demo deployment uses Bedrock as its production provider.

What Fought Back

The most frustrating problem was a deployment bug where the live root URL served the wrong frontend.
The backend was healthy.  /api/health  on the deployed service returned:
{ "status": "ok", "provider": "bedrock", "archiveStorage": "s3" }
The load balancer was responding and the container was alive. But the browser, at the root URL, showed an old static landing page instead of the React app. The HTML carried the legacy page's title,  Conti-Newty Workbench — The Multiplayer Company Brain & Knowledge OS , rather than the Vite entry point I expected:
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
The first guess was that the Docker image wasn't copying the frontend build, or that the load balancer was routing to the wrong target. Neither was true. The frontend build existed in the image.
The actual cause was that the repo had two frontend entry points,  public/index.html  and  apps/web/index.html , and Express was serving static files from both at the root:
app.use(express.static(clientDistDir));
app.use(express.static(publicDir));
Two static directories mounted at  /  means the legacy page can answer requests meant for the new app. The legacy  public/index.html  was the one being served.
The fix was to make  dist/client  the only frontend at the root and move the legacy files under their own path:
app.use('/public', express.static(publicDir));
The SPA fallback (the catch-all route that serves the React app for client-side URLs) now returns  dist/client/index.html . API, Socket.IO and generated-application routes are explicitly excluded from it so it doesn't swallow them.
We verified this locally against the built server:
ROOT=200
ROOT_HAS_REACT=True
ROOT_HAS_LEGACY=False
HEALTH=200
The fix is not live yet. The public URL still needs the corrected image pushed to ECR, a new ECS task definition revision, and a rollout behind the load balancer.

What Changed During the Build

The scope grew much faster than I expected. It started as a Company Brain and AI workspace idea. By the end it had picked up authentication, organizations, agents, source grounding, realtime collaboration, change governance, Tribal Memory, connectors, generated applications, an AWS deployment pipeline, and a new product direction called Live Agent Learning.
The build went through roughly these phases:
  • Core backend: Node.js/TypeScript/Express, authentication, org lifecycle, Prisma layer, basic authorization
  • AI Brain and app generation: agent runner, brain tools, source grounding, citations, multi-provider support, app generator, connector foundations
  • Realtime collaboration: Socket.IO, presence, cursors, file-viewing status, typing state, task rooms, live task events
  • Frontend workspace: the React/Vite app, landing page, and the Brain, Ask, Work, Agents, Software, Members, Activity, Security, Settings and Archives surfaces
  • Multiplayer AI enhancements: better task collaboration and realtime agent activity
  • AWS workflow: Bedrock integration, S3 archive support, Docker, ECS task definitions, migration workflow, Secrets Manager
  • Live Agent Learning direction: defining Live Sessions, Driver/Observer control, human redirects, Skill Entries, skill review and confirmed skill reuse
That growth showed me the project needed a much sharper line between what's implemented and what's planned, which is why this post is so explicit about status.

Results

Here is where each feature stands today, not where it's headed.
Feature
Status
Company Brain (workspace files, brain tools, Tribal Memory)
Partially working
Source-grounded answers and citations
Partially working
Multiplayer collaboration
Realtime foundation working; full collaborative agent workflow planned
Human-reviewed file changes
Early implementation working; full governed workflow planned
Internal app generation (Small Software Cloud)
Partially working
Tribal Memory
Partially working
Secure workspace governance
Partially working
Live Agent Learning (Sessions, Driver/Observer, redirects, Skill Entries)
Planned, not implemented
Workspace and agent access. Workspace-scoped file storage, directory listing, file read/write/search, read-only paths, path traversal protection and brain tools are in place.
Citations. The agent runner gathers context, tracks sources, extracts citations and removes any it can't verify, using a format like  [source: path/to/file.md:14-22] . Retrieval reliability, citation presentation, freshness tracking and conflict handling between documents still need work.
Realtime. Socket.IO rooms, presence, cursors, typing indicators and live task events are built and working. Live Sessions, Driver/Observer roles, session-specific authorization, redirects and replay are not.
Change review. Proposing changes, generating diffs, and requiring approval before an atomic apply all work. It isn't yet connected to sessions or to the loop that turns corrections into reusable knowledge.
App generation. The system can generate, deploy and sandbox-run small internal apps. Production-grade isolation, lifecycle management, versioning and resource limits are open work.
Deployment. The backend is live and healthy on ECS/Fargate behind the load balancer. The frontend routing fix is verified locally but not yet live.
I haven't captured formal metrics such as latency, answer accuracy or citation precision, so this section sticks to what I can observe working.

Limitations

  • The frontend fix isn't deployed to the live environment yet.
  • Source grounding works but lacks stronger retrieval, ranking, and conflict and freshness handling.
  • Only the realtime infrastructure exists. The full multiplayer AI experience (Live Sessions, Driver/Observer, redirects) doesn't.
  • Approved changes aren't linked to sessions or to any mechanism that turns corrections into reusable knowledge.
  • App generation lacks production-grade sandboxing, versioning and lifecycle management.
  • Governance has a solid base (auth, roles, audit logs, credential encryption) but isn't enterprise-grade. There's no SSO/SCIM and no formal retention or compliance controls.
  • The production database service (RDS, Aurora or other) is unconfirmed.
  • The deployed Bedrock model version and the locked Tailwind version should be checked against the live configuration and the lockfile, not assumed from the README or  package.json  range.

What We Learned

The strongest part of this project isn't the landing page. It's that Conti-Newty turned out to be more than a prompt interface. It connects workspace knowledge, agent execution, citations, human review, collaboration and app generation into one loop, with workspace boundaries, permission checks, path validation and audit records underneath. None of that shows up in a screenshot, but it matters for anything that touches a real company's data.
An AI product isn't about connecting a model to a prompt. The hard parts are supplying the right context, keeping it inside real permission boundaries, showing evidence for claims, handling wrong output gracefully, letting humans review changes, and recording what happened. The loop that matters isn't:
Prompt → Answer
It's:
Context → Agent work → Human review → Correction → Reusable knowledge
If I rebuilt this, I'd do three things differently:
  1. Pick the core abstraction earlier. The system is organized around  AgentTask , but the direction I want is organized around  LiveSession : participants, a driver, an observer, agent state, redirects, evidence, replay and applied skills.
  1. Split the legacy static frontend from the React frontend on day one. Having both  public/index.html  and  apps/web/index.html  in one repo is exactly what made the deployment bug possible.
  1. Pin down the production database and migration workflow sooner. Local and production configurations need to stay aligned as the schema changes.

What's Next

None of this is implemented. It's the plan.
Live Agent Learning is the direction I'm building toward:
Workspace → LiveSession → Participants → AgentTask
→ Session Events → Redirect → Skill Proposal
→ Human Review → Confirmed Skill → Future Skill Reuse
That means Live Sessions with real participants, Driver and Observer roles, and human redirects mid-session. The system would generate a Skill Proposal from what happened in a session, a human would confirm it before it becomes a real skill, and confirmed skills would be reused in later sessions.
The immediate next step is finishing the deployment loop: rebuild and push the corrected image, then roll it out to ECS so the public URL reflects the frontend fix.

Final Takeaway

Conti-Newty is a working foundation, not a finished product. It has a real backend, a real agent loop, real source grounding and a real AWS pipeline, and the collaboration and learning pieces are still to be built. Keeping the line between what runs and what's planned clear mattered more to this project than any single feature.

Links

  • Live deployment:  Conti-Newty  (still serves the pre-fix frontend until the new image is deployed)
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article