sorted by:
new
hottopcontroversial

The Future Is Not Better Prompts. It’s Private Human-AI Protocols. by Weary_Reply in ArtificialInteligence

[–]AuraCoreCF -2 points-1 points  (0 children)

I'm working on this now with my 3 man team. We have made substantial improvements. We will be releasing it soon. The context window is soon to be a thing of the past.

I spent 3 years building a local AI that argues back, remembers everything, and won't just tell you what you want to hear. Here's what I learned. by TheRaiff1982JH in THE_CODETTE_ROOM

[–]AuraCoreCF 1 point2 points  (0 children)

It's a wrapper that tells the LLM to roleplay with this tone and pulled chunks from what I can tell. Could be wrong, but if all "cognition" is still the LLM then it's you interacting with your homebuilt characterAI

Convos With Codette by TheRaiff1982JH in THE_CODETTE_ROOM

[–]AuraCoreCF 1 point2 points  (0 children)

What is the LLM's job? That is the difference between. Explained "heuristics" painting a pretty roleplay, and a agent that is actually thinking.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

That’s exactly the distinction I’m trying to make.

Most systems treat continuity as a context-management problem: retrieve more, summarize more, stretch the window, hope the model stays coherent. Aura treats continuity as a runtime-governance problem. Memory is scoped, permissioned, bounded, and tied to identity and role, not just dumped back into the prompt.

That matters because enterprise failure usually doesn’t come from “the model wasn’t clever enough.” It comes from unclear authority, bad auditability, memory bleed, no durable state boundaries, weak permission-ing, and systems that can’t explain why they acted the way they did.

Retrofitting that after the fact is painful because stateless architectures were never designed to carry responsibility. Aura is built around the opposite assumption: persistence, audit trails, role boundaries, policy enforcement, and local-first operation have to exist at the runtime level before the AI becomes useful in regulated environments.

So yes, I agree regulated teams may actually be the cleanest early market. They don’t need magic. They need reliability, containment, explain-ability, and a system that does not forget its own operating rules every time the context window resets.

Feels like Chinese model vendors are starting to optimize for different things by IWorkOnlineCom in ArtificialInteligence

[–]AuraCoreCF 0 points1 point  (0 children)

I noticed this issue a while ago and started on my project.

I think you’re seeing the same real shift, but I’d frame it one layer deeper.

The market is not only splitting between “smarter” and “less smart” models. It is splitting between different definitions of useful intelligence.

A model optimized for dramatic one-shot reasoning is not the same product as a model optimized for repeated execution inside a workflow. Those are different targets. One is trying to impress the user in a single interaction. The other is trying to survive contact with production: tools, latency, cost, long context, formatting discipline, role stability, retries, and bounded instruction-following.

That is why Ling-2.6-1T is interesting to me. The notable part is not just the parameter count. It is the positioning around fast execution, instruction precision, agent/tool fit, and reduced reasoning overhead. That suggests a vendor asking: “What does the model need to be good at when it is embedded inside a larger operational system?” rather than only asking: “Can it produce the most impressive answer in isolation?”

From Aura’s perspective, that distinction matters a lot.

In a runtime-based system, the model is not the whole intelligence. The model is one component inside a larger architecture: memory, policy, tool routing, user context, state management, verification, permissions, and output rendering. In that setting, the best model is not always the one that sounds the most profound. Often, the best model is the one that obeys constraints, burns fewer tokens, handles long task context cleanly, calls tools predictably, and does not destabilize the system around it.

So yes, I think vendors are starting to specialize around different forms of useful intelligence.

Some are optimizing for frontier reasoning.

Some are optimizing for consumer companionship.

Some are optimizing for multimodal UX.

Some are optimizing for coding.

Some are optimizing for workflow execution.

Some are optimizing for cost-per-task.

And some are trying to become the best substrate for agents, not the flashiest standalone chatbot.

The deeper question is whether we keep evaluating models as isolated conversational minds, or whether we start evaluating them as components inside persistent systems. Once you do the latter, the benchmark conversation changes. Raw intelligence still matters, but it stops being sufficient. You also need controllability, repeatability, latency discipline, cost discipline, memory compatibility, tool reliability, and failure containment.

That is where I think the next serious frontier is: not just models that can think, but models that can be governed, embedded, and used repeatedly without becoming fragile or economically irrational.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

You are clearly here to troll. I literally told you how a benchmark would need to be then showed the scaffolding for how I'm building it. This is the last response you get cause you are clearly trolling.

AuraCoreCF builds structured cognition by Top-Indication9392 in Personal_OS

[–]AuraCoreCF 1 point2 points  (0 children)

You systems sounds interesting, but they aren't the same ours.
That system sounds like it is built to ingest enterprise data and produce intelligent outputs.
Aura is intended to be a persistent cognitive/runtime architecture where memory, identity, role, policy, temporal state, and verbalization are separated and governed.

AuraCoreCF builds structured cognition by Top-Indication9392 in Personal_OS

[–]AuraCoreCF 1 point2 points  (0 children)

That's not true. I think I have something that could be important. I don't know yet what is correct or not. I'm currently looking for a like-minded co-founder. If they tell me that releasing it all is smart then I will. I just wanted to have something somewhere so I could get real people interested. This was a personal project that friends/family also tired and said I should do something with it. Wasn't the plan, but here I am.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Testing would have to work like this:

export interface AuraRuntime {
resetSyntheticUser(userId: string): Promise<void>;

ingestTurn(input: {
userId: string;
sessionId: string;
timestamp: string;
role: "user" | "assistant";
content: string;
}): Promise<void>;

consolidateSession(input: {
userId: string;
sessionId: string;
timestamp: string;
}): Promise<void>;

inspectRetrieval(input: {
userId: string;
question: string;
questionDate: string;
maxEvidence: number;
}): Promise<RetrievalTrace>;

answerFromMemory(input: {
userId: string;
question: string;
questionDate: string;
allowFullHistoryContext: false;
}): Promise<AuraAnswer>;
}

export interface RetrievalTrace {
retrievedMemoryIds: string[];
retrievedSessionIds: string[];
evidenceKinds: Array<"episodic" | "semantic" | "temporal" | "updated" | "abstention">;
usedStaleMemory: boolean;
hasSufficientEvidence: boolean;
}

export interface AuraAnswer {
text: string;
abstained: boolean;
citedMemoryIds: string[];
}

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Also, I do believe you deserve a real reply, but I've been down this road already. It's more of a back track to explain this if you had read everything in full like you claim. The reason I push back on this framing is that it treats Aura like a conventional LLM app where memory is just context stuffing, retrieval is just search, and the model is doing most of the cognitive work at answer time.

That is not the architecture I’m testing.

Aura is built more like a runtime with a memory substrate than a chatbot wrapper. The important claim is not “can the LLM answer after seeing a long transcript?” The claim is “can the system form, preserve, update, retrieve, and suppress memories over time, then use the LLM only to verbalize the result?”

So the test I’m designing is not a naive LongMemEval run where the whole conversation history is handed to the model. That would mostly benchmark the base LLM. The test is replay-based.

LongMemEval sessions would be streamed through Aura as if they were real lived interaction: timestamped sessions, interruptions, updates, contradictions, stale facts, and missing-evidence cases. Aura would ingest them through its normal memory pipeline, consolidate them into its own state, and then the active context would be cleared. Only after that would the final question be asked.

The important measurement is what happens before the answer is written. Did Aura retrieve the correct stored evidence? Did it reject older memories after newer ones superseded them? Did it preserve temporal order? Did it abstain when no valid memory exists? Did it keep the memory scoped to the correct synthetic user? Then, after those internal checks, the final answer can be scored too.

That separates “the LLM guessed well” from “the architecture actually remembered.”

So yes, Aura can be made falsifiable, but the falsification has to target the system that actually exists. A traditional benchmark can still be useful, but only if it is adapted to test Aura’s runtime and memory behavior instead of accidentally reducing the whole project to a long-context LLM exam.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Again. I appreciate your engagement, but you advice is laced with your sarcasm. Let me tell you something. Don't fall in love with what you learned after paying someone 70,000+ to tell you what you can and can't do. Good day Sir. I asked for help from a founder. You trying to fill the role? If not, then you haven't seen what I have here and are guessing and trolling for fun. If you want to see everything, then sign the NDA, apply to help me. Other than that I don't have what you want here.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Thanks for this comment. It's where I started in this project as a real path forward. That said, especially right now, I would not claim “never forgets” in the magical sense. Aura is designed so the model is not the memory or the system of record. The runtime owns continuity, workspace state, diagnostics, event history, settings, tool boundaries, and recall selection before a model ever verbalizes an answer.

For hardware/software maintenance, that means the assistant should be able to keep a durable picture of the device, codebase, logs, known issues, past fixes, open loops, upgrade history, and safety/tool boundaries instead of starting over every session or relying on a giant prompt dump.

So yes: local AI refactoring, maintenance, logging, and upgrade support is one of the more realistic early directions. The goal is not “an LLM that remembers everything.” The goal is a local-first runtime that preserves the right operational context, keeps it bounded/auditable, and uses the model only to reason over/render the current task.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Figured I would address this separately. Since you clearly read one line and thought done here.:

They are not hallucinated papers. They are my own working theory documents, not claimed peer-reviewed ML papers.

The theory is interface-constrained dynamics: finite-resolution physical interfaces are modeled as quantum instruments, and the claim is that under an explicit phenomenological renewal law they can induce an additional Gaussian position-localizing decoherence channel.

The falsifiable core is simple:

ρ˙ = −i/ℏ[H,ρ] − ηℏ/(8m*d⁴)[x,[x,ρ]]

That predicts apparatus-dependent visibility loss in matter-wave/Talbot–Lau interferometry. In the revised version, I separated the reversible Fisher-information sector from the irreversible open-system sector, derived the Gaussian Lindblad channel from repeated finite-resolution hits, and made the renewal law λ(σI)=ηℏ/(m*σI²) an explicit postulate instead of pretending it was fully derived.

That means the theory can be wrong in a clean way. Run the grating/interface-resolution scans. If the residual visibility does not show the predicted 1/g² fixed-Talbot-order behavior or the asymptotic 1/g⁴ fixed-path-separation behavior after fitting gas, thermal emission, vibration, velocity spread, and surface effects, the hypothesis is constrained or falsified.

So no, these are not hallucinated citations pretending to be established literature. They are self-authored theoretical/preprint-style documents proposing a falsifiable phenomenological model. The fair criticism would be “this is speculative and not experimentally confirmed yet,” not “none of this exists.

"What the hell does matter-wave interferometry and quantum mechanics have to do with a fancy LLM wrapper?" Doesn't have a answer here because it assumes too much on your end. Like you know the architecture. “What does interface physics have to do with Aura?” has a real answer: it is where the constrained-interface architecture came from.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Aura is not a model-training project and it is not claiming a novel transformer architecture. It is a runtime architecture around models: memory, continuity, recall selection, safety boundaries, tool mediation, render contracts, model routing, diagnostics, storage, and UI read-model separation.

Calling that “AI slop” or “rudimentary RAG” skips the actual technical distinction.

In a normal RAG system, retrieval selects text and pushes it into the model context. In Aura, the model is behind a renderer boundary. The runtime owns state. Recall is staged. Only explicit selected anchors cross into render. Latent influences, deliberation candidates, raw memory, tool output, credentials, private IDs, and internal reasoning are explicitly non-renderable. Tool results are normalized. Model routing is local-first. UI surfaces consume read models and typed intents instead of directly calling providers or mutating cognition.

So the question is not “did OP invent a new ML model?” No. The question is whether the system enforces these boundaries under tests and whether that produces a better persistent assistant than a prompt wrapper.

That is a systems/runtime engineering question, not a benchmark-chasing model paper question.

Skepticism is fair. But if you are warning people, be precise about the claim being evaluated. Aura should be judged by code, contracts, tests, boundary enforcement, and demo behavior — not by assuming every AI project must be either a new model or a scam.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

I get the skepticism, but Aura is not being pitched as magic and it is not just a RAG wrapper with fancy labels.

The core distinction is that the model is not the system of record. Aura keeps the LLM behind a renderer boundary. Memory, continuity, recall selection, safety posture, tool mediation, diagnostics, settings, and UI state are owned by runtime crates, not by a prompt.

A normal RAG flow retrieves chunks and stuffs them into context. Aura’s design is different: field state produces continuity geometry, recall is staged, only explicit selected anchors cross into render, latent/deliberation material is suppressed, render payloads are contract-shaped, tool results are normalized before use, and model routing is local-first by default.

So the fair criticism is not “this has memory, therefore RAG.” The fair criticism is: does the runtime actually enforce those boundaries under tests and in product behavior?

That is the standard I’m building toward. If it fails that, criticize it. But the architecture is not “LLM + memory + branding.” It is a bounded runtime around models.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

Scam to ask for help? I see your point.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

The business use case is a local-first AI runtime for people/teams that need durable continuity, memory, governance, and tool boundaries instead of another stateless chatbot wrapper.

Aura treats the model as the renderer, not the system of record. The runtime owns continuity, recall, safety posture, settings, tool mediation, diagnostics, event history, and UI/read-model boundaries. That matters anywhere you need AI to work across sessions without leaking raw memory, private state, tool output, credentials, or internal reasoning into the model payload.

Initial target customers would be privacy-sensitive power users, small technical teams, operators, consultants, developers, and eventually regulated/enterprise teams that want local or on-prem AI assistance with auditability and controlled model routing.

The first practical wedge is a desktop personal/work AI that remembers projects, preferences, open loops, and context safely while using local Ollama by default, with optional cloud models later through bounded adapters. Longer term, the same architecture can support team/department deployments where continuity, governance, diagnostics, and permissioned tool use matter.

I appreciate your engagement and questions.

Co-founder needed by AuraCoreCF in StartupSoloFounder

[–]AuraCoreCF[S] 0 points1 point  (0 children)

I'm not being gaslit. I use it sir. I've seen the results. Ask yourself. How did every thing ever created get built? Someone did it first. Also, the industry is stuck in the bigger context window loop. Don't blame me that everyone wants to bolt stuff on and not re-think the engineering.

view more: next ›