The Autonomous Causal Engine
CIT is a persistent cognitive system designed to reason through cause and effect, maintain user-scoped memory, work in the background, analyze files and code, use tools, and produce concrete artifacts rather than limiting every interaction to a single prompt and response.
CIT Education — a starting point for study and exam preparation
Education is one of CIT's two specialized public entry points. Instead of asking students to invent a prompt, CIT Education starts with recognizable goals: understanding a difficult topic, organizing course material, preparing for an exam and continuing a learning project over time.
Understand a lesson
Ask for explanations, examples and step-by-step reasoning using your own topic or notes.
Prepare for exams
Break a syllabus into topics, prioritize gaps and build a realistic study sequence.
Use a private workspace
Attach supported notes and files so your explanations can refer to the actual course materials.
Continue learning
Return to your CIT account to continue work using available account-scoped history and context.
The authenticated CIT Education Studio includes persistent courses, dated study plans, question-and-answer flashcards, adaptive spaced review, and a specialized CIT reasoning mode. Study progress signals come from saved reviews and are not exam-score predictions.
CIT Creators — from the next content idea to a production plan
Creators is CIT's second specialized public entry point. Its central problem is clear: a creator needs another useful idea, then needs to turn it into something they can actually publish. CIT can support brainstorming, concept comparison, outlining and ongoing creative work.
Idea exploration
Describe the channel, its subject and audience, then develop relevant ideas instead of disconnected suggestions.
Video structure
Build opening hooks, outlines, script directions and production checklists.
Series continuity
Use prior project context to revisit ideas and keep creative direction consistent across sessions.
Reasoned choices
Compare concepts and explain assumptions and trade-offs; do not present hypothetical performance as guaranteed views.
CIT Creators Studio stores channel context, a private idea bank, original content proposals, editorial scheduling and user-supplied post metrics. Automatic publishing and direct platform analytics require separate authorized integrations and are not enabled by these tools.
How CIT processes a request
A user request enters a multi-stage cognitive pipeline rather than being treated as isolated text. Depending on the request, CIT can combine conversational history, long-term memory, causal context, current system state, workspace attachments, external information, and available tools before producing a final answer.
CIT also maintains internal state outside individual turns. The architecture includes working-memory management, confidence checks, world-model simulation, action gating, consolidation, and background processes.
Causal Engine
The causal layer is intended to distinguish relationships that merely occur together from relationships that may produce downstream effects. CIT maintains a causal graph and can evaluate intervention-style questions: what changes if a particular factor is changed, removed, or forced?
Causal graph
Stores structured relationships between concepts, observations, decisions, and effects instead of relying only on flat text history.
Intervention analysis
Supports do()-style reasoning to estimate how an intervention can propagate through known causal relationships.
Counterfactual simulation
World-model and scenario components can evaluate possible outcomes before an action or recommendation is accepted.
Impact tracing
Especially useful for root-cause analysis, code auditing, dependency chains, and questions where one change can affect several systems.
Persistent memory
CIT separates immediate working context from longer-lived memory. Recent conversational turns can be restored into the active conversation, while important information can be consolidated into persistent causal structures and long-term stores.
Working memory
Maintains a bounded active context for current tasks and salient information.
Hippocampal consolidation
Moves sufficiently valuable or surprising information from temporary state toward persistent memory.
Information surprise
Novelty and information value can influence whether an observation is worth consolidating.
User isolation
Conversation history and workspace context are scoped to the authenticated user rather than identified by IP address.
Persistence does not mean that every sentence is automatically treated as permanent truth. CIT can prioritize, consolidate, and retrieve information according to its memory pipeline.
Autonomous background operation
CIT is designed to keep a supervised runtime active even when no HTTP request is currently being processed. The background system can maintain timing, evaluate internal state, perform research work, consolidate memory, and decide whether a finding is important enough to surface to the user.
- Heartbeat: keeps scheduled cognitive processes alive independently of individual messages.
- Autogeom: can generate internal research or exploration drives while the system is idle.
- Background research: can gather and retain cross-domain findings on a schedule.
- Circadian phases: support wake/consolidation behavior and scheduled state transitions.
- Proactivity: may surface meaningful findings without producing constant idle chatter.
Private workspace, uploads, and multimodal analysis
Each authenticated user has an isolated workspace. From the chat composer, users can add files or photos and create files or folders. CIT can inspect supported attachments and use their contents as context for the current task.
Supported analysis
Text and source files are read directly. CIT also has extraction paths for PDF, DOCX, XLSX, PPTX, CSV, JSON, configuration files, and many common source-code formats. Images can be supplied to the visual analysis path.
Storage model
Workspace metadata is persisted in the runtime data layer. File bytes can be stored in S3-compatible object storage in production, with a local fallback for development. Access checks are performed using the authenticated user_id.
Default limits
The production configuration currently supports a default maximum of 50 MB per file and 500 MB of workspace storage per user. These limits are deployment-configurable.
Causal Code Audit Mode
When source or configuration files are attached and the user asks for an audit, review, debugging, correctness, security, or performance analysis, CIT activates a dedicated causal audit contract.
Findings are separated into confirmed issues and hypotheses. A confirmed issue must be supported by code actually provided in the audit scope. When several files are supplied, CIT can trace imports, shared state, async ordering, persistence boundaries, authentication flow, side effects, and API contracts where the available code supports those relationships.
Audits can cover correctness, security, race conditions, persistence/data-loss risk, performance traps, error handling, interface mismatches, and maintainability. CIT can also create a corrected file or an audit report inside the user's workspace when requested.
Research and source selection
CIT contains source-selection logic that distinguishes requests that can be answered from internal context from requests that require external or time-sensitive information. Web research is handled as an explicit capability rather than assumed for every message.
Background research is domain-agnostic: it is not restricted to one field. Findings can be persisted and later surfaced when relevant. As with any external information, users should verify high-stakes decisions against authoritative sources.
Tools and generated artifacts
CIT can invoke registered tools when a task requires an action rather than prose alone. Workspace tools are constrained to the authenticated user's isolated storage.
Create folders
Build nested project structures inside the user workspace.
Create files
Generate source files, text, Markdown, JSON, CSV, HTML, and other text-based formats.
Create artifacts
Produce PDF, DOCX, XLSX, PPTX, ZIP and other supported downloadable outputs.
Read workspace files
Retrieve and analyze existing user-owned files through authenticated workspace tools.
Persistence and living conversation
CIT is built around one continuing conversation stream rather than disposable sessions. Chat messages, cognitive runtime state, research findings, and other durable records can be stored in PostgreSQL in production, with local database fallbacks available for development.
The interface hydrates recent conversation history after refresh, while retention can remain unlimited at the persistence layer. Runtime state is keyed to the authenticated user.
Authentication, security, and privacy
- Email/password authentication uses salted password hashing.
- Browser sessions use opaque HTTP-only cookies and persisted token digests.
- A post-login verification gate protects access to chat and telemetry.
- Google sign-in can be enabled by the service administrator.
- User memory and workspace data are resolved from authenticated account identity, not client IP address.
- Workspace downloads, reads, deletes, and writes validate file ownership against the active user.
- Production object storage is private; application access controls determine which authenticated user may retrieve an object.
For privacy terms and data-handling information, see Privacy and Terms.
Plans and access
CIT offers Starter, Pro, and Master subscription tiers. The public pricing page is the source of truth for current pricing and plan presentation. Users access CIT through their account; they are not required to configure the language-inference provider themselves.
Founder-only system controls
Some capabilities are intentionally not part of the ordinary user product. The authenticated Founder/Admin account can access administrative workflows such as Media & PR approval and the System Evolution pipeline.
System Evolution uses a proposal-first workflow: a proposed structural code change is inspected and sandbox-validated before it can enter a persistent proposal queue. Execution remains an explicit Founder-controlled action. Protected system modules are not available for unrestricted self-modification.
CIT Collective Learning — a weekly improvement cycle
CIT can learn from recurring user-reported problems in general chat, Education and Creators. This product learning is different from retraining a language model: it converts privacy-safe feedback categories into evidence-based suggestions and Founder-reviewed code proposals.
Voluntary contribution
Users explicitly enable anonymous improvement feedback. The setting is off by default, and disabling it removes their individual learning signals. Conversation contents and uploaded files are not added to the collective dataset.
Weekly causal review
Every Monday after 00:05 Europe/Bucharest, CIT compiles the previous completed week's categories and recurring symptoms. It marks possible causes as hypotheses rather than confirmed defects.
Account anonymity
A specific problem category is visible in Founder reports only when at least three different consenting accounts reported it. No individual account, quote or conversation is exposed in the summary.
Self-development, with approval
Where a narrowly scoped change can be identified, CIT can prepare a code update and submit it to the existing sandbox. Only validated proposals enter the Founder queue; CIT cannot approve or deploy its own changes.
Founder view: System Evolution → Weekly Learning. The report ranks suggested changes using feedback recurrence and number of contributors, and distinguishes observation from proven causality.
Efficient CIT processing
CIT uses five complementary cost controls around its existing cognitive engine, including Education and Creators. The goal is to spend the model budget on reasoning that matters, rather than repeatedly transferring identical instructions or unnecessary data.
Anthropic prompt caching
A stable CIT system-prefix can be reused by the provider, while per-user context and live telemetry stay outside that cached block. Cache duration is configurable.
Cheap preprocessing cascade
When configured and useful, a smaller model extracts candidate facts and structured intent information before the primary CIT synthesis. The original evidence remains authoritative.
Context pruning
Large non-code file contexts and web snippets can be reduced while preserving document provenance and relevant passages. Original uploaded files are not modified.
Execution budgets
Authenticated requests have hard limits of four model reasoning calls and four tool operations; unattended background inference also has an adjustable daily limit.
Safe semantic caching
Suitable stable explanations can be reused within the same authenticated account context when matching is sufficiently strong. User-private creative work and live information are excluded from reuse.
Only exact cache hits avoid both model and embedding calls. A semantic check can require a low-cost embedding request. Cost and token outcomes vary by actual request patterns, model pricing and provider cache availability. A Founder-only metrics endpoint reports aggregate counts without publishing conversation text.
What CIT does not guarantee
- CIT can make mistakes. Important technical, legal, medical, financial, or operational decisions should be independently verified.
- Causal reasoning quality depends on the evidence and relationships available to the system. Missing context can limit certainty.
- A one-file code audit cannot prove behavior that depends on unseen modules, runtime configuration, infrastructure, or dependency versions.
- File support is broad but not every proprietary binary format can be semantically extracted.
- Background research and proactive behavior depend on deployment configuration and service availability.
- Generated files should be reviewed before production use.
Example workflows
Document analysis
Attach a PDF and spreadsheet: “Compare these, identify contradictions, and create a PDF report.”
Code audit
Attach source files: “Audit this code, trace the root causes of failures, and tell me exactly what to change and test.”
Project generation
“Create a folder called website with index.html, style.css, app.js and README.md.”
Research
Ask a question requiring current information and CIT can select an external research path when available.
Root-cause reasoning
“If I change component A, what downstream components can fail and why?”
Corrected artifact
“Review this file, apply the corrections, and create a fixed version in my workspace.”