{"aura-hero-glyph.fe06eb6459":"Tab","aura-hero-glyph.2b9eceb7a8":"Enter","aura-hero-glyph.9ae56a8bbc":"6 tools · 1 patch","aura-hero-glyph.f11fb3bba3":"MANUAL","aura-hero-glyph.5490b1bffa":"approve patch","aura-hero-glyph.81c0d915fa":"Activity","aura-hero-glyph.a4114a83f4":"Todos","aura-hero-glyph.01f8495722":"awaiting approval","aura-hero-glyph.4b6a9f3bae":"    return Err(SessionExpired);","aura-hero-glyph.3d1d356818":"+ if expires_at <= now()","aura-hero-glyph.0cf751dc60":"- if expires_at < now()","aura-hero-glyph.62cb9b146a":"src/auth/session.rs · hunk 2/3","aura-hero-glyph.acb9b5a1d4":"3 hunks proposed","aura-hero-glyph.adc543c50e":"expires_at · 4 matches","aura-hero-glyph.19eaff68e3":"src/auth/session.rs · 217 lines","aura-hero-glyph.00c2de8503":"src/auth/mod.rs · 89 lines","aura-hero-glyph.d10567a9db":"src/auth/** · 7 files","aura-hero-glyph.3d3caaa651":".dweve/plans/auth-session.md · 64 lines","aura-hero-glyph.122544cd97":"execute .dweve/plans/auth-session.md","aura-hero-glyph.c127f294a0":"main · clean","aura-hero-glyph.1627510b24":"Branch","aura-hero-glyph.519e39132b":"Path","aura-hero-glyph.68c2cc7f0c":"Model","aura-hero-glyph.ca520cdc27":"v1.0.0 · Autonomous Development Agent","aura-hero-glyph.20c7c5522f":"Ready","aura-hero-glyph.14681ef679":"Dweve Aura [v1.0.0]","aura-hero-glyph.de4c77b587":"Dweve Loom","aura-hero-glyph.46a96d0c5f":"patch · 3 hunks proposed","aura-hero-glyph.bda9ee855f":"grep · expires_at","aura-hero-glyph.e588f0aef2":"read · src/auth/session.rs","aura-hero-glyph.67ec040c80":"read · src/auth/mod.rs","aura-hero-glyph.da622feffd":"grep · src/auth/**","aura-hero-glyph.e1ac049133":"read · .dweve/plans/auth-session.md","aura-hero-glyph.4546870d62":"Update .dweve/status/","aura-hero-glyph.c803918c60":"Run cargo test --all","aura-hero-glyph.49f13245be":"Patch session expiry","aura-hero-glyph.d5850f39bc":"Map auth module","aura-hero-glyph.42ff189f74":"Read .dweve/plans/auth-session.md","aura-hero-glyph.session":"session","aura-hero-glyph.input":"input","aura-hero-glyph.send":"send","aura-hero-glyph.focus":"focus","aura-hero-glyph.quit":"quit","aura-business-glyph.9ea21d197d":"Talk to Dweve","aura-business-glyph.afaf0e09a4":"Pilot in days","aura-business-glyph.825b6f99f2":"Runs on your infrastructure","aura-business-glyph.6af74613cf":"Built in Europe","aura-business-glyph.7c3dde4a8b":"4 of 4 covered","aura-business-glyph.b7a3f27883":"Risk removed","aura-business-glyph.5fc6b0293a":"In control","aura-business-glyph.2e496b198c":"What your team gets","aura-business-glyph.005fd98d0b":"Outcomes board","aura-business-glyph.d5020461c9":"No evidence for reviewers","aura-business-glyph.6743ec794c":"Silent, unreviewed changes","aura-business-glyph.e709996a62":"Personal data exposure","aura-business-glyph.9eb1263e9a":"Code leaving your control","aura-business-glyph.54fdb48ce3":"The assistant, the search, the memory and the audit log folded into one binary.","aura-business-glyph.7ec5ec329f":"platform you run","aura-business-glyph.b58b5a8ced":"One","aura-business-glyph.1aaa79fa6d":"Bug hunts, boilerplate, refactors and onboarding spread across seven tools.","aura-business-glyph.c08957a94f":"on routine work","aura-business-glyph.9e25a34e63":"Hours","aura-consumer-glyph.8d2d5afbc0":"Stays on your computer","aura-consumer-glyph.d1fe4c69e0":"You can always undo it","aura-consumer-glyph.201c3f5f98":"Nothing changes until you say so","aura-consumer-glyph.0a9ca31422":"Yes, go ahead","aura-consumer-glyph.c49920673a":"Of course. Here is what I would like to do.","aura-consumer-glyph.49f67b5c92":"Aura answers","aura-consumer-glyph.238bd1fb75":"Can you help me fix this little mistake in my code?","aura-consumer-glyph.7ed149da71":"You ask","aura-consumer-glyph.92ee0cb489":"Here to help","aura-consumer-glyph.0d13217083":"Your patient helper","aura-consumer-glyph.af0854de67":"Aura","aura-consumer-glyph.81fc483d05":"Wait for you to say yes","aura-consumer-glyph.bfa310d18c":"Suggest a small fix","aura-consumer-glyph.0eb05d6a2a":"Look at the file you mean","aura-ask-grid.af0854de67":"Aura","aura-b-close.9e3c1d591d":"What the claims stand on","aura-b-close.100ec4462d":"evidence","aura-b-close.d6fa024673":"the business band","aura-b-close.7e9e5f3a1b":"one native Rust binary","aura-b-close.466f1eb810":"25+ built-in tools","aura-b-close.368df3249c":"fifteen-stage pipeline","aura-b-close.6fec4ca245":"BLAKE3 audit trail","aura-b-close.6f997fae0c":"deterministic goal checks","aura-b-close.8c86def2e7":"local, private, cloud postures","aura-b-close.6a307fbf1e":"no unmeasured productivity claims","aura-b-close.81cac219fd":"current facts only","aura-b-close-loop.de4a6df381":"The loop around the task","aura-b-close-loop.e4a74ba91e":"closed loop","aura-b-close-loop.3edaffdc77":"goal in, outcome out","aura-b-close-loop.db9a022b75":"goal","aura-b-close-loop.bed97175b0":"plan","aura-b-close-loop.76f3b5a717":"act","aura-b-close-loop.4f4224f44a":"observe","aura-b-close-loop.f8bfc15dde":"steer","aura-b-close-loop.86a4261d84":"verify","aura-b-close-loop.d1c10fb0e6":"judge","aura-b-close-loop.f7dc07550a":"finish or replan","aura-b-close-loop.d700a456bd":"the first test fails, Verify returns to Plan","aura-b-close-loop.5b5e3b3cd1":"the second patch passes, the goal closes","aura-b-close-loop.0cbde99016":"each node opens its artefact","aura-b-close-loop.97e1fd885d":"the patch is not the endpoint","aura-b-close-loop.c730c27f18":"close the session on token expiry","aura-b-close-loop.61bf8faa6c":"5 steps, revised after replan","aura-b-close-loop.88bd0f4352":"1 failing to 0 failing","aura-b-close-loop.580f1d1ffd":"no operator message this run","aura-b-close-loop.ce8ce0e3fe":"every criterion satisfied","aura-b-close-loop.741f10656a":"goal satisfied, loop closes","aura-b-deployment.79b00c45ed":"Four postures, one loop","aura-b-deployment.bc109fb076":"portable","aura-b-deployment.14fef0393d":"outbound by policy","aura-b-deployment.e068381bbd":"laptop","aura-b-deployment.b67626b7bb":"CI runner","aura-b-deployment.b3db8f4abb":"private server","aura-b-deployment.e75afa49d1":"isolated environment","aura-b-deployment.8f3f678c30":"each posture shows its model and its outbound boundary","aura-b-deployment.c676f15064":"the loop does not move","aura-b-deployment.2ede35bd77":"the custody boundary is chosen","aura-b-goal-card.87f73cc3d3":"A goal, four criteria","aura-b-goal-card.4c6ec2d7f1":"judged","aura-b-goal-card.be3a0f01da":"three pass, one replans","aura-b-goal-card.5bd72c48ad":"test passes","aura-b-goal-card.a53be2595e":"file exists","aura-b-goal-card.83ec8c5792":"output matches","aura-b-goal-card.012a1773f2":"quality clears","aura-b-goal-card.f5036f3b58":"the final state reads goal satisfied, each criterion green","aura-b-goal-card.cb2a83df92":"completion is a predicate","aura-b-goal-card.1051d7b08f":"not a final paragraph","aura-b-hidden-load.e4e414a34c":"One developer, seven surfaces","aura-b-hidden-load.a24070e43d":"carrying","aura-b-hidden-load.b99f7ccd94":"cards moved by hand","aura-b-hidden-load.27a9612b32":"assistant","aura-b-hidden-load.ec122f54cf":"shell","aura-b-hidden-load.394046ef6e":"test runner","aura-b-hidden-load.5819778898":"Git","aura-b-hidden-load.8eec7bc461":"security","aura-b-hidden-load.8557b33974":"issue tracker","aura-b-hidden-load.0b7cec9c67":"reviewer","aura-b-hidden-load.d2eede619d":"the cards become one loop state inside Aura","aura-b-hidden-load.eefd5c8afe":"state in one attention","aura-b-hidden-load.346170ef36":"state in the runtime","aura-b-integration.b0e508720d":"The estate around the loop","aura-b-integration.ae4cf21cde":"composed","aura-b-integration.5ea87e08e4":"the loop stays central","aura-b-integration.ab41949825":"editor","aura-b-integration.46d551dae6":"terminal","aura-b-integration.13844228ea":"CI","aura-b-integration.94cbffb24e":"MCP server","aura-b-integration.f7d513fd94":"Git host","aura-b-integration.9bd91395b7":"SIEM","aura-b-integration.b5cd57a488":"the loop remains central while the estate surrounds it","aura-b-integration.2ffd420e53":"any editor, your CI","aura-b-integration.8db6b6ef55":"one loop","aura-b-loop-glyph.00baa97f24":"One task, one loop","aura-b-loop-glyph.3c49d9cc3c":"running","aura-b-loop-glyph.85e1b6106a":"the patch is one state","aura-b-loop-glyph.793d84e8b3":"goal set","aura-b-loop-glyph.cb7c5004f7":"plan drafted","aura-b-loop-glyph.f4cd44b8f6":"files read","aura-b-loop-glyph.67cc5f221c":"patch proposed","aura-b-loop-glyph.b3a5309e0d":"test failed","aura-b-loop-glyph.89efc3f4e7":"replan","aura-b-loop-glyph.1956889480":"test passed","aura-b-loop-glyph.5ae84b0a5b":"goal satisfied","aura-b-loop-glyph.3030171a6a":"> aura goal fix:session-expiry","aura-b-loop-glyph.7caf98aad5":"the patch begins awaiting approval","aura-b-loop-glyph.30515cb81d":"the goal closes the loop","aura-b-memory.8d5852ec4c":"A correction becomes memory","aura-b-memory.c192bc980a":"recalled","aura-b-memory.420364fe1f":"reviewed and budgeted","aura-b-memory.bda91a1da9":"correction in session one","aura-b-memory.ac36b00c12":"reviewed project memory","aura-b-memory.904ee00802":"ranked into a later plan","aura-b-memory.654cc2b281":"a visible forget action removes it","aura-b-memory.82170e7bb8":"inspectable and deletable","aura-b-memory.6ef12a1016":"not a recurring prompt","aura-b-model-swap.8d047a149a":"The model node changes","aura-b-model-swap.c21c2fe66c":"swappable","aura-b-model-swap.29da5190ad":"the loop is fixed","aura-b-model-swap.0fed3b96cc":"Loom","aura-b-model-swap.d804e2a212":"supported API","aura-b-model-swap.5fb639ed9a":"private endpoint","aura-b-model-swap.688a890cc5":"advisory CLI","aura-b-model-swap.2db83d5efb":"tool, policy, quality, memory, and audit nodes do not move","aura-b-model-swap.911c6de470":"change the model","aura-b-model-swap.10a5d24257":"keep the engineering loop","aura-b-model-swap.a55d8da739":"drives the same loop","aura-b-multi-agent.eb659182c1":"Four patterns, one repository","aura-b-multi-agent.f9fff6a815":"coordinated","aura-b-multi-agent.34eecae151":"the work ledger","aura-b-multi-agent.25dd7d521e":"chains","aura-b-multi-agent.1a92520138":"parallel","aura-b-multi-agent.4629383656":"teams","aura-b-multi-agent.248a20b62e":"background","aura-b-multi-agent.90d361f753":"file claims prevent two agents from editing the same path","aura-b-multi-agent.30c17bb12d":"more capacity","aura-b-multi-agent.2858513e87":"not more confusion","aura-b-open-loop.86b58f4bb8":"Prompt, patch, then manual work","aura-b-open-loop.52a4494c35":"open loop","aura-b-open-loop.f4494cfadb":"the human closes it","aura-b-open-loop.742cf35828":"prompt to model to patch","aura-b-open-loop.d303113843":"run tests","aura-b-open-loop.61e62b213a":"review","aura-b-open-loop.8eec7bc461":"security","aura-b-open-loop.5c6fa26f49":"undo","aura-b-open-loop.76ab1eecf2":"provider log","aura-b-open-loop.7379ce1e37":"incident note","aura-b-open-loop.712a5d7f51":"the model calls tools","aura-b-open-loop.8669a47120":"the human carries the state","aura-b-quality-stages.caa780b8ba":"Six quality stages","aura-b-quality-stages.18cd42d86d":"gated","aura-b-quality-stages.5eb8e00607":"a failure feeds the loop","aura-b-quality-stages.785987648f":"format","aura-b-quality-stages.b504838caf":"lint","aura-b-quality-stages.36d0981b33":"compile","aura-b-quality-stages.a94a8fe5cc":"test","aura-b-quality-stages.cea2eb3659":"doc tests","aura-b-quality-stages.7876153ada":"audit","aura-b-quality-stages.fa7d132401":"compile passes, tests fail, repair, tests pass, audit completes","aura-b-quality-stages.9862d5f59a":"fail fast","aura-b-quality-stages.718520b0b3":"fix in place","aura-b-record.8c783c3463":"The record assembles","aura-b-record.c8c78ad28a":"verifiable","aura-b-record.8d031edd74":"alongside the loop","aura-b-record.6dbd1b376c":"goal and criteria","aura-b-record.1a3b6b31a0":"model routes","aura-b-record.cc8b5f4d0a":"tool calls","aura-b-record.abdf4ec3a4":"checkpoints","aura-b-record.68a72ea9a0":"quality results","aura-b-record.4f293e6ca4":"final status","aura-b-record.96e711c7dc":"verify-audit checks the chain at completion","aura-b-record.58a5b5c95f":"the diff shows what changed","aura-b-record.6261aff8fd":"the record shows how","aura-b-review-rail.866a72634f":"A live control rail","aura-b-review-rail.dca7e58fc1":"steerable","aura-b-review-rail.b8dad0f782":"authority stays live","aura-b-review-rail.7b2c7f146a":"Approve","aura-b-review-rail.58cfcdca5e":"Redirect","aura-b-review-rail.781961bc81":"Pause","aura-b-review-rail.6f3abbe484":"Abort","aura-b-review-rail.39fc721248":"Undo","aura-b-review-rail.529191c869":"one instruction changes the next tool call without a reset","aura-b-review-rail.af7d16c175":"review inside the work","aura-b-review-rail.47c96f55d7":"not after autonomy ends","aura-b-review-rail.51c3370661":"the patch call proceeds as planned","aura-b-review-rail.f303e4c5da":"the next call targets the failing test first","aura-b-review-rail.f6847fdb84":"the loop holds before the next tool call","aura-b-review-rail.b063c25048":"the session ends and the work is preserved","aura-b-review-rail.9427d6f0a5":"the last checkpoint is restored in place","aura-b-review-rail.ef434cc5d8":"next tool call","aura-b-runtime-atlas.4dbc10df89":"The runtime, as loop parts","aura-b-runtime-atlas.2d46938a7e":"unified","aura-b-runtime-atlas.597bf2db8c":"one native binary","aura-b-runtime-atlas.2aeede80be":"control","aura-b-runtime-atlas.5ba2688dff":"models","aura-b-runtime-atlas.0284c6ac58":"tools","aura-b-runtime-atlas.8eec7bc461":"security","aura-b-runtime-atlas.aa4a5f8125":"state","aura-b-runtime-atlas.df43804bfd":"coordinate","aura-b-runtime-atlas.5ea2d81a89":"interface","aura-b-runtime-atlas.100ec4462d":"evidence","aura-b-runtime-atlas.66b20f8b2b":"optional providers and tools stay external where selected","aura-b-runtime-atlas.74a1d53533":"one control model","aura-b-runtime-atlas.5979aaa1a7":"not assembled services","aura-b-runtime-atlas.5aa1dab4f8":"drives the loop","aura-b-runtime-atlas.0b7c697923":"reasons over the task","aura-b-runtime-atlas.3121a45458":"runs bounded actions","aura-b-runtime-atlas.44aa478d29":"guards every call","aura-b-runtime-atlas.7b8f2d1376":"remembers the project","aura-b-runtime-atlas.c7e695d40d":"runs agents in parallel","aura-b-runtime-atlas.ac60ac55d2":"where you work","aura-b-runtime-atlas.0a5329ed1e":"proves what happened","aura-b-security-layers.7401769d23":"Three layers, one call","aura-b-security-layers.fef19892d5":"defended","aura-b-security-layers.778ab652a9":"action, content, environment","aura-b-security-layers.c86f83055e":"action layer","aura-b-security-layers.6f62a3d48b":"content layer","aura-b-security-layers.0064e7478c":"infrastructure layer","aura-b-security-layers.9905e1d38b":"each layer shows a concrete control and its result","aura-b-security-layers.c2dc9db224":"enforceable boundaries","aura-b-security-layers.b568a77d17":"evidence for review","aura-b-tool-boundary.38934e6d67":"One request, one pipeline","aura-b-tool-boundary.c072e8329e":"bounded","aura-b-tool-boundary.acc4cbbdc7":"fifteen stages","aura-b-tool-boundary.720ed56669":"built-in tool","aura-b-tool-boundary.a25c7a05cf":"MCP tool","aura-b-tool-boundary.c0094fe9f9":"extension tool","aura-b-tool-boundary.0f989d9515":"built-in, MCP, and extension tools join at the same ingress","aura-b-tool-boundary.2d0154059a":"scope, permission, shell analysis, checkpoint, sanitise, audit","aura-b-tool-boundary.c166035cfb":"one agent, many tools","aura-b-tool-boundary.c0f3aa8f37":"one boundary, no exception","aura-business-sides.a0853da24b":"Spec sheet","aura-business-visuals.40417391c5":"Aura · resolves","aura-business-visuals.271973aefe":"xMidYMid meet","aura-business-visuals.3e91add48a":"BOARD","aura-c-checks.6734f37cb6":"A failed check returns","aura-c-checks.75e4aedce4":"checked","aura-c-checks.f4581ca1df":"your project decides","aura-c-checks.bc3c24f374":"format and lint","aura-c-checks.36d0981b33":"compile","aura-c-checks.04d13fd0aa":"tests","aura-c-checks.7876153ada":"audit","aura-c-checks.7ff8b7d8f7":"one failed test returns to the loop, then passes","aura-c-checks.2a667eb1b1":"a plausible patch is not enough","aura-c-checks.d403cb4090":"the build has to pass","aura-c-checks.7bf5f1bafe":"first run","aura-c-checks.9eb28c543f":"second run","aura-c-checks.5f5f8758f5":"failed","aura-c-checks.6a9f6c3fff":"passed","aura-c-checks.e8a7d6f2bc":"repair","aura-c-checks.ceb4ed3d1e":"returns to the loop","aura-c-close.926fe901b0":"What you keep in control of","aura-c-close.100ec4462d":"evidence","aura-c-close.f123a39d1f":"the consumer band","aura-c-close.750dc3bf10":"one native program","aura-c-close.8c58d3332d":"any editor","aura-c-close.ffe021481f":"project-scoped access","aura-c-close.67b29baf71":"mid-turn steering","aura-c-close.f907a42000":"checkpoints and undo","aura-c-close.c88bec0321":"cross-session memory","aura-c-close.8279848dfe":"verifiable audit when enabled","aura-c-close.8b3139fd33":"the question stays simple","aura-c-close.3f07208a48":"you stay in command","aura-c-close.8af56de682":"you","aura-c-close.5ca6ab20a3":"in command","aura-c-goal-mode.166fff52c4":"A goal with a finish line","aura-c-goal-mode.5fc7e38bff":"open","aura-c-goal-mode.8847739f7d":"progress you can see","aura-c-goal-mode.4d284fdc84":"the test passes","aura-c-goal-mode.3eaa0b9cfe":"the file exists","aura-c-goal-mode.0edd6a141c":"the output matches","aura-c-goal-mode.cb2ab794ac":"it stops when the goal is met, when you stop it, or when it cannot go on honestly","aura-c-goal-mode.f01fce7813":"done is a condition","aura-c-goal-mode.62d818d6b7":"not the last sentence","aura-c-goal-mode.0becc159a3":"the goal","aura-c-goal-mode.dbd43f6c45":"goal met","aura-c-goal-mode.896d7a9fb3":"you stop it","aura-c-goal-mode.885c3bd0a8":"cannot continue honestly","aura-c-goal-mode.ceafa97ffa":"met","aura-c-goal-mode.e22586930a":"pending","aura-c-sides.462845276c":"You say it plainly","aura-c-sides.2b78b1a0f0":"three steps","aura-c-sides.5b0e46b9e4":"You describe the work","aura-c-sides.c66d144b92":"Fix the login, add a test, explain this part. No commands to memorise.","aura-c-sides.882e4f2485":"Aura reads your project","aura-c-sides.eaee3fa84e":"It looks at your own files and notes, not a generic example.","aura-c-sides.b6698c7a4c":"It becomes a clear goal","aura-c-sides.63257c3312":"A small target it can check when the work is done.","aura-c-sides.8a9abb51e6":"plain words in","aura-c-sides.619591e74b":"a clear goal out","aura-c-sides.bb64f7d88c":"When is it done?","aura-c-sides.4a4c7b2eca":"you decide","aura-c-sides.759a42354b":"Done can mean","aura-c-sides.4d284fdc84":"the test passes","aura-c-sides.3eaa0b9cfe":"the file exists","aura-c-sides.0edd6a141c":"the output matches","aura-c-sides.de121c67af":"It also stops when","aura-c-sides.420db47931":"you tell it to stop","aura-c-sides.9c041396d3":"it cannot go on honestly","aura-c-sides.bb78267c2d":"When should it stop?","aura-c-sides.2f86920220":"When the goal you set is truly met.","aura-c-sides.beab0815b6":"you set the finish line","aura-c-sides.2996f98d07":"it holds to it","aura-c-sides.f1699c0c6e":"It starts in your work","aura-c-sides.f549877964":"not a template","aura-c-sides.56e11d7823":"Reads your files","aura-c-sides.8a505662c3":"The real work in front of you.","aura-c-sides.e37ea0a274":"Follows the trail","aura-c-sides.e59dacd188":"From one part to the parts it touches.","aura-c-sides.741279fc2d":"Checks the history","aura-c-sides.6b0784b5eb":"What changed and when.","aura-c-sides.f0ded5a2e6":"Recalls your notes","aura-c-sides.fc489af89b":"Only what you allow it to see.","aura-c-sides.b6f7648a44":"Points to the spot","aura-c-sides.92e25a3579":"The exact file and line behind its plan.","aura-c-sides.be1308e0f6":"your project first","aura-c-sides.51d3837b62":"answers you can trace","aura-c-sides.6d8a44c8c9":"See the plan first","aura-c-sides.1fbfa763a7":"before any change","aura-c-sides.f25c85f4ee":"Files to read","aura-c-sides.ce02064a81":"What it needs to look at","aura-c-sides.adcc7aee87":"listed","aura-c-sides.6b3697ec92":"Checks to run","aura-c-sides.fa9cfe96e0":"How it will confirm the work","aura-c-sides.661f9f790e":"Changes to approve","aura-c-sides.ba88ce8ba7":"Nothing edits without your nod","aura-c-sides.fa8ccfaa32":"flagged","aura-c-sides.4a4d85b04b":"Room to adjust","aura-c-sides.87a36f45f8":"The plan updates as it learns","aura-c-sides.98aadb3708":"live","aura-c-sides.443a2988e9":"the steps up front","aura-c-sides.4c5c3dcf92":"no surprises","aura-c-sides.fbf471fe47":"Run, ask, or never","aura-c-sides.e82760ba2c":"tool by tool","aura-c-sides.b1b392607d":"Run","aura-c-sides.49607fec4c":"Safe looking-around happens on its own.","aura-c-sides.3562777bc6":"Ask","aura-c-sides.e302e9cef4":"Edits and commands wait for your yes.","aura-c-sides.80c3052d33":"Never","aura-c-sides.d77dddcd0c":"Switch off anything you do not want.","aura-c-sides.be9c2d0d5a":"Stay inside","aura-c-sides.f5251f76c6":"It keeps to your project unless you allow more.","aura-c-sides.931a585f14":"you hold the keys","aura-c-sides.79ecff3693":"one setting each","aura-c-sides.47977fc20c":"Nudge it midway","aura-c-sides.b2bc2c1b70":"no restart","aura-c-sides.bf71aca24a":"Without steering","aura-c-sides.81a11c03e1":"You wait, then redo","aura-c-sides.148836ac63":"wrong turn","aura-c-sides.1b480158e1":"stop","aura-c-sides.91a5868691":"start over","aura-c-sides.649caf34e5":"re-explain","aura-c-sides.d88dbf19a7":"With Aura","aura-c-sides.17f60e974d":"You correct in the moment","aura-c-sides.91c5d401a4":"type a note","aura-c-sides.bd73cddabf":"it adjusts","aura-c-sides.6ef5bae6f3":"keeps going","aura-c-sides.27375beb70":"same session","aura-c-sides.75c597585a":"catch it early","aura-c-sides.64ba1d0f81":"keep the thread","aura-c-sides.e57e825ef9":"Your project decides","aura-c-sides.d15d3bf964":"not a guess","aura-c-sides.c4858ded2a":"A fix that looks right","aura-c-sides.51a9ec65ae":"looks right","aura-c-sides.bf382d7884":"reads well","aura-c-sides.43a2d42a17":"never run","aura-c-sides.704a7a6b12":"might break the build","aura-c-sides.854649ea35":"A checked change","aura-c-sides.b33f338ad0":"proven","aura-c-sides.bc3c24f374":"style and safety checks","aura-c-sides.cd4065bd4e":"tests run","aura-c-sides.c9e3c324fa":"a failure is fixed","aura-c-sides.c5391bd76d":"no blind patches","aura-c-sides.71fad40acd":"green before done","aura-c-sides.21051bb354":"Always a way back","aura-c-sides.4e41d3d706":"try things safely","aura-c-sides.9e4955edb5":"1 tap","aura-c-sides.de446cff70":"Undo the last","aura-c-sides.bd8cedb6ec":"Step back the most recent change","aura-c-sides.f25470201a":"many","aura-c-sides.53c38a8006":"Or several","aura-c-sides.e475113df7":"Roll back a run of edits","aura-c-sides.0d612c12d2":"auto","aura-c-sides.3f55f9502f":"Saved first","aura-c-sides.39141993ee":"A restore point before edits","aura-c-sides.b77cad1467":"aside","aura-c-sides.3202b0fb7d":"Bigger tries","aura-c-sides.fa2e321eac":"A separate copy keeps main work safe","aura-c-sides.f831a051f1":"experiment freely","aura-c-sides.d2530bb089":"nothing is stuck","aura-c-sides.33589033f3":"It remembers","aura-c-sides.c683405361":"what you tell it","aura-c-sides.9dfd349ebe":"Preferences","aura-c-sides.c95a351492":"How you like things","aura-c-sides.344a1b5fb0":"Project facts","aura-c-sides.6e49df9766":"Details about your work","aura-c-sides.ccc70f2dc6":"Corrections","aura-c-sides.13dd431661":"Fixes you made once","aura-c-sides.c7790422f4":"See them","aura-c-sides.0695923c0d":"Look at what it kept","aura-c-sides.bce0641417":"Search","aura-c-sides.f98d5ed80d":"Find any note","aura-c-sides.03d5d80199":"Forget","aura-c-sides.721a6d6ae5":"Remove any time","aura-c-sides.84985463a6":"correct it once","aura-c-sides.b16a771f7a":"kept for next time","aura-c-sides.197baf3d24":"Choose its brain","aura-c-sides.edb958705d":"where it thinks","aura-c-sides.9a6215377d":"On your computer","aura-c-sides.29e2a6fa3d":"Its thinking stays with you.","aura-c-sides.9be34046ca":"LOCAL","aura-c-sides.6f57fa8eb0":"In the cloud","aura-c-sides.6ebd68af44":"You choose what to send out.","aura-c-sides.7be6b26592":"CLOUD","aura-c-sides.fc17c3334b":"Your own provider","aura-c-sides.219d7bfa62":"The one your team already uses.","aura-c-sides.25b8673c57":"YOURS","aura-c-sides.836a090730":"Let Aura choose","aura-c-sides.71d7d6f7d9":"It picks a fit and falls back if one is away.","aura-c-sides.50c3f10f5b":"AUTO","aura-c-sides.1a763b4465":"one helper","aura-c-sides.1b93f6e32a":"your choice of brain","aura-c-sides.1fd0213c46":"Room to work","aura-c-sides.93f414e89c":"tabs and tasks","aura-c-sides.50a9bf5db1":"Several sessions","aura-c-sides.01eb025f6e":"Keep more than one job open.","aura-c-sides.1f93d1a4cb":"TABS","aura-c-sides.1fbf937256":"Ready-made routines","aura-c-sides.fa819cb947":"Fix, build, tidy, review.","aura-c-sides.6c45aeee6f":"FLOWS","aura-c-sides.3f13f06451":"Work in the background","aura-c-sides.0e4320e017":"Long jobs run while you carry on.","aura-c-sides.9f5da1d189":"BG","aura-c-sides.7b9783a284":"more than a chat box","aura-c-sides.83f6a010e0":"a place to work","aura-c-sides.797b3a4684":"More hands when needed","aura-c-sides.4ef47b57cc":"specialists team up","aura-c-sides.83791ae169":"Hand off","aura-c-sides.efdfb116a0":"One specialist passes work to another.","aura-c-sides.2d8e3f561a":"In parallel","aura-c-sides.68e099b014":"A few attempts at once.","aura-c-sides.44c50f0c14":"As a team","aura-c-sides.c36455a381":"Coordinated on one project.","aura-c-sides.8a9e0232d0":"In the open","aura-c-sides.3d41310009":"Every handoff stays visible.","aura-c-sides.f264604373":"In the background","aura-c-sides.ca4110d021":"Long tasks run while you work.","aura-c-sides.93836939d3":"No clashes","aura-c-sides.4c2d69643b":"File claims stop silent overlaps.","aura-c-sides.133bda4d19":"more help","aura-c-sides.f5270ef2d4":"still one clear thread","aura-c-sides.7baf092ac9":"A record of the work","aura-c-sides.d39f1c3902":"check it later","aura-c-sides.3485593010":"What ran","aura-c-sides.c7d3d59da7":"Which tools did the work.","aura-c-sides.7e4b91991b":"What changed","aura-c-sides.c4e5e2abe2":"Every file it touched.","aura-c-sides.b1253b0867":"Which brain","aura-c-sides.ccf567ebb9":"The helper it used.","aura-c-sides.86af8fd51c":"Safety events","aura-c-sides.8a003c1cf2":"When the watchdog stepped in.","aura-c-sides.b7a3d0f4b4":"Session state","aura-c-sides.db7ae26cb8":"How the work paused and resumed.","aura-c-sides.acaaaf846b":"Tamper-evident","aura-c-sides.61f4ed0023":"Later checks reveal any edit.","aura-c-sides.01e87a65d9":"it shows what changed","aura-c-sides.6261aff8fd":"the record shows how","aura-c-loop-glyph.a6feedfcfc":"A small friendly loop","aura-c-loop-glyph.48d46b1cf3":"helping","aura-c-loop-glyph.251b8669f8":"more than a suggestion","aura-c-loop-glyph.e09315fa02":"look","aura-c-loop-glyph.bed97175b0":"plan","aura-c-loop-glyph.7550b672e1":"change","aura-c-loop-glyph.d56d985300":"check","aura-c-loop-glyph.1c8f09270f":"ask","aura-c-loop-glyph.2cce4a92f4":"finish","aura-c-loop-glyph.9ebfe71fde":"the conversation expands into a loop that keeps working toward the goal","aura-c-loop-glyph.a5a9219cd8":"it suggests a fix","aura-c-loop-glyph.c2f28cc5a2":"then it checks the fix","aura-c-loop-glyph.93a35a6e80":"the sidebar keeps disappearing","aura-c-loop-glyph.a504ce0f10":"let me look, change it, then check it holds","aura-c-loop-glyph.828f966619":"expands into","aura-c-memory.7b3684e36f":"A correction you can forget","aura-c-memory.1e61fe1e47":"kept","aura-c-memory.5ea7e72e1f":"across sessions","aura-c-memory.6018578ba0":"you correct it once","aura-c-memory.436230f7d6":"it becomes a memory card","aura-c-memory.cf796cdfd3":"it appears in a later plan","aura-c-memory.badd832852":"a visible forget action removes it whenever you want","aura-c-memory.0eceae53ab":"correct once","aura-c-memory.6554ce8a6d":"do not repeat it","aura-c-memory.1d96ae3691":"session one","aura-c-memory.5d41440dd3":"project memory","aura-c-memory.880a50dc3e":"session two","aura-c-memory.6b8e17ddd0":"use tabs, not spaces, in this project","aura-c-models.d1d4d67bb5":"A simple helper picker","aura-c-models.3fe6938286":"chosen","aura-c-models.4ee02bbcd4":"locality shown honestly","aura-c-models.939bb46a04":"local","aura-c-models.e80721793c":"private","aura-c-models.000e793db7":"cloud","aura-c-models.082ccb0d65":"advisory","aura-c-models.91808c5bf6":"a helper on your computer keeps the thinking with you, a cloud helper receives what you send","aura-c-models.2e8e972ea4":"use the helper you choose","aura-c-models.850ff2fc0a":"the loop stays the same","aura-c-models.dd66e039cf":"stays with you","aura-c-models.aa3d389873":"sent to a provider","aura-c-models.c03c99ad16":"locality boundary","aura-c-models.835f3b50e3":"selected","aura-c-more-help.9e9783410f":"Helpers on one board","aura-c-more-help.f9fff6a815":"coordinated","aura-c-more-help.c6432958c5":"each with a claim","aura-c-more-help.2875bec277":"a chain of specialists","aura-c-more-help.9186dd1a66":"parallel attempts","aura-c-more-help.4e2b5809ea":"a coordinated team","aura-c-more-help.4eec30569d":"file claims mean two sessions do not silently edit the same path","aura-c-more-help.133bda4d19":"more help","aura-c-more-help.c949f2ddcb":"no copy and paste","aura-c-more-help.19ed74c94f":"task board","aura-c-more-help.d72041bc0d":"claims","aura-c-more-help.d6e91b2a4c":"in progress","aura-c-more-help.efcc77141d":"queued","aura-c-more-help.e5fd9cfe0e":"done","aura-c-permissions.8e32d6c5a9":"A control per tool","aura-c-permissions.65c10dc354":"set","aura-c-permissions.945f0635af":"the settings are yours","aura-c-permissions.bb1261b3a0":"run automatically","aura-c-permissions.37a19f2b55":"ask first","aura-c-permissions.85777c03b7":"never","aura-c-permissions.234a461863":"access stays inside the project unless you allow more","aura-c-permissions.256b35c754":"conservative by default","aura-c-permissions.d4056f2c4d":"loosened when you choose","aura-c-permissions.ff71eb852a":"edit files","aura-c-permissions.d303113843":"run tests","aura-c-permissions.1bbff4c25a":"read the web","aura-c-permissions.cf98bd552c":"run commands","aura-c-permissions.1937c4c28f":"tool","aura-c-plain-words.dfe6dc1031":"Four requests, four goals","aura-c-plain-words.64b8cefeeb":"understood","aura-c-plain-words.0d6378289e":"not a list of steps","aura-c-plain-words.6467af839e":"why does this keep failing","aura-c-plain-words.5c3f36de5e":"where is login handled","aura-c-plain-words.4cf8a3450b":"add tests for this function","aura-c-plain-words.5a04ad5c07":"split this large file","aura-c-plain-words.99d8907e77":"each request becomes a small goal card, not a chat answer","aura-c-plain-words.766af5ca73":"you describe the work","aura-c-plain-words.e048014e5d":"Aura finds the steps","aura-c-plain-words.db9a022b75":"goal","aura-c-plain-words.4e58ac7873":"becomes","aura-c-plain-words.69a58ae186":"Aura plan","aura-c-plain-words.262b5a9e0c":"Reads it","aura-c-plain-words.6442306c13":"Makes the change","aura-c-plain-words.b7b72f199d":"Checks the result","aura-c-plain-words.b9889a194d":"Each request becomes a goal Aura can check","aura-c-plain-words.c6af4217f7":"Reads the logs","aura-c-plain-words.227e1bf368":"Finds the cause","aura-c-plain-words.02babecae1":"Confirms it is gone","aura-c-plain-words.463e65d41d":"Searches the project","aura-c-plain-words.b6f7648a44":"Points to the spot","aura-c-plain-words.c5857c6e03":"Opens the file","aura-c-plain-words.22f1f8b3ae":"Reads the function","aura-c-plain-words.d79d1bac06":"Writes the checks","aura-c-plain-words.8969e4284f":"Runs them to make sure they pass","aura-c-plain-words.0ef378eacb":"Reads the file","aura-c-plain-words.88b82d365f":"Divides it cleanly","aura-c-plain-words.1bb562b749":"Checks nothing broke","aura-c-plain-words.dbc9d683a0":"cause found, trouble gone","aura-c-plain-words.78ea47e171":"found in the sign-in file","aura-c-plain-words.0cec448503":"4 new checks, all pass","aura-c-plain-words.0316d5d85e":"one file becomes three","aura-c-plan-view.0fc8a83850":"A five-step plan","aura-c-plan-view.2238839604":"visible","aura-c-plan-view.cdd51f7209":"with a plan version","aura-c-plan-view.8a3ae31bd0":"read the files","aura-c-plan-view.bbe58f5c1d":"propose the change","aura-c-plan-view.50c3d81ffa":"run the checks","aura-c-plan-view.c61fdda109":"ask where needed","aura-c-plan-view.16089180c0":"replan on new info","aura-c-plan-view.91facc600b":"each step shows progress and the plan can change","aura-c-plan-view.27845548f6":"see the steps","aura-c-plan-view.6077756fda":"before the work disappears","aura-c-plan-view.e5fd9cfe0e":"done","aura-c-plan-view.d6e91b2a4c":"in progress","aura-c-plan-view.0dc14e0059":"to do","aura-c-plan-view.3201aaa124":"plan version","aura-c-project-first.76d1a87618":"What shaped the plan","aura-c-project-first.a7afddb682":"read","aura-c-project-first.001cf4877f":"within your access","aura-c-project-first.4522a7f4aa":"your project layout","aura-c-project-first.a85392aaba":"search results","aura-c-project-first.968509ab2a":"your current version","aura-c-project-first.c5ccfc3ec4":"one relevant memory","aura-c-project-first.4b8647b1c5":"it points to the exact files that shaped the plan","aura-c-project-first.cce1f2b600":"starts in your code","aura-c-project-first.d03a9bdb36":"not a generic example","aura-c-project-first.7c003df330":"the plan","aura-c-project-first.fba96d3cbe":"names the exact files","aura-c-project-first.0de6589821":"what it read","aura-c-project-first.3d9e0f8746":"your project","aura-c-project-first.61d0c14efd":"sign-in area","aura-c-project-first.c61cafa3a5":"the login screen","aura-c-project-first.ec3b8486f4":"where you sign in","aura-c-project-first.94c12f4b8c":"where sessions live","aura-c-project-first.9ea289b47b":"the sign-in update","aura-c-project-first.d5604ee4e4":"your usual style","aura-c-project-first.4781c4b44e":"the sign-in file","aura-c-project-first.128049c372":"the sessions file","aura-c-record.bfcd179fd5":"A friendly session receipt","aura-c-record.bec262808f":"valid","aura-c-record.f83c1391ce":"in plain rows","aura-c-record.db9a022b75":"goal","aura-c-record.a1f13b3bc2":"files","aura-c-record.0284c6ac58":"tools","aura-c-record.7354fb826f":"checks","aura-c-record.59494695a3":"approval","aura-c-record.4d57832a60":"final state","aura-c-record.083df741c6":"the audit chain can be verified later to detect modification","aura-c-record.58a5b5c95f":"it shows exactly what changed","aura-c-record.6261aff8fd":"the record shows how","aura-c-record.e437dbe950":"session receipt","aura-c-record.c17b0baf1b":"fix the login redirect","aura-c-record.38bdb0be02":"3 files changed","aura-c-record.e912934351":"read, changed, checked","aura-c-record.0cd1893aca":"all checks and tests passed","aura-c-record.c6df5ea629":"you approved","aura-c-record.5ae84b0a5b":"goal satisfied","aura-c-record.d094d89a6d":"You can open","aura-c-record.7fcf0e3a4a":"Which tools ran","aura-c-record.b16c14a38a":"Which files changed","aura-c-record.c2b7261a5b":"Which helper answered","aura-c-record.f0950c8ffd":"Whether the chain holds","aura-c-record.5b0e17aac2":"Nothing here can be quietly edited.","aura-c-steering.6438b18f37":"A correction between steps","aura-c-steering.98aadb3708":"live","aura-c-steering.7c25e6250e":"no restart needed","aura-c-steering.7ea9535baa":"Aura reads","aura-c-steering.6d591e82a2":"you type a correction","aura-c-steering.086ec0ae93":"the next step changes","aura-c-steering.d6124e0dce":"the context stays warm, so you do not re-explain the project","aura-c-steering.605b9e7726":"redirect mid-run","aura-c-steering.7af6535203":"before the wrong path finishes","aura-c-steering.3c89cbed8b":"read login.ts","aura-c-steering.1b800c3aee":"patch the header","aura-c-steering.84075b88b9":"patch the sidebar","aura-c-steering.910d4bb617":"your correction","aura-c-steering.e22586930a":"pending","aura-c-steering.13a1891af7":"updated","aura-c-undo.4965db7102":"A checkpoint timeline","aura-c-undo.e2daf02871":"recoverable","aura-c-undo.77c604b3c0":"a way back","aura-c-undo.539e5b2267":"undo one","aura-c-undo.f6f4e9b9a3":"undo several","aura-c-undo.f82c7a6f6e":"a worktree branch","aura-c-undo.b82466a20b":"checkpoints are captured before supported file edits","aura-c-undo.3a4a336b84":"try the change","aura-c-undo.8d95394625":"keep the way back","aura-c-undo.c9bc849a96":"now","aura-c-undo.5c528ebc85":"checkpoint","aura-c-undo.6dd881212a":"restore point","aura-c-workspace.c09b44e27a":"One keyboard-first space","aura-c-workspace.e18a89f9cc":"busy","aura-c-workspace.566d134f8b":"several tasks at once","aura-c-workspace.4549482f8a":"tabs across the top","aura-c-workspace.4dd05a204a":"one active workflow","aura-c-workspace.5c5a5f3c2e":"one background task","aura-c-workspace.c14229a0c7":"one restored session","aura-c-workspace.0b1115aaab":"your files, changes, checks, and record stay in one place","aura-c-workspace.0583f1aad0":"many tasks","aura-c-workspace.456e7bb250":"one workspace","aura-c-workspace.2bb6b986c5":"active","aura-c-workspace.c784901b44":"in the background","aura-c-workspace.6e39dd1851":"restored","aura-c-workspace.2f09a31246":"fix login","aura-c-workspace.3e0716146d":"add tests","aura-c-workspace.6a5b832257":"clean up","aura-c-workspace.3add7b9612":"notes","aura-c-workspace.5fc7e38bff":"open","aura-c-workspace.7550b672e1":"change","aura-c-workspace.df6ad19037":"run","aura-c-workspace.c61cafa3a5":"the login screen","aura-c-workspace.60128b2c25":"the sidebar","aura-c-workspace.e6a18e5997":"the checks","aura-e-audit-chain.ecc82c6be9":"A hash-linked sequence","aura-e-audit-chain.c8c78ad28a":"verifiable","aura-e-audit-chain.183bb7ee25":"previous-entry digest","aura-e-audit-chain.76a8bc0c09":"sequence and time","aura-e-audit-chain.2eda7d938e":"event kind","aura-e-audit-chain.aef6a69a89":"previous digest","aura-e-audit-chain.5a60037da0":"verify walks the chain","aura-e-audit-chain.4ce431649a":"a provider-boundary marker shows where hidden internals stop","aura-e-audit-chain.7851cb25d6":"tamper-evident","aura-e-audit-chain.2f4f94613b":"not immutable, not a blockchain","aura-e-audit-chain.1aaccfb5b1":"seq","aura-e-audit-chain.5006ed0248":"event","aura-e-audit-chain.859d455b8e":"prev","aura-e-audit-chain.2923f6fa36":"digest","aura-e-audit-chain.e8e1891050":"provider boundary","aura-e-backend-registry.823f6f31dd":"Four shapes, one interface","aura-e-backend-registry.2a86b14ebb":"normalised","aura-e-backend-registry.c7408bd258":"the opt-in router above","aura-e-backend-registry.ac0b0e71f9":"native API","aura-e-backend-registry.9f2f38a0dd":"compatible API","aura-e-backend-registry.702f30f47a":"local or private endpoint","aura-e-backend-registry.47e75daab6":"CLI advisory","aura-e-backend-registry.9c24aac557":"the router selects the cheapest configured model that meets the capability need","aura-e-backend-registry.cbcdf92347":"the model is normalised","aura-e-backend-registry.970fd71199":"the route is recorded","aura-e-backend-registry.c5be5b3d86":"capability","aura-e-backend-registry.3a310f6ec7":"streaming","aura-e-backend-registry.cc8b5f4d0a":"tool calls","aura-e-backend-registry.d659558d7b":"one adapter interface","aura-e-backend-registry.835f3b50e3":"selected","aura-e-backend-registry.7e0efbb551":"One interface behind four adapters.","aura-e-bash-analysis.ada4ab4607":"Three commands, three verdicts","aura-e-bash-analysis.05812b700f":"classified","aura-e-bash-analysis.93e85daa84":"AST, not substring","aura-e-bash-analysis.fc6a6b54f6":"a safe command runs","aura-e-bash-analysis.0c22fc0821":"a quoted dangerous string stays safe","aura-e-bash-analysis.b9eaae9104":"a real pipe to shell is stopped","aura-e-bash-analysis.8ec8885724":"tokens, operators, quoting, and escaping are evaluated before execution","aura-e-bash-analysis.549d47fb5b":"structure decides","aura-e-bash-analysis.54eccf9703":"not a brittle substring list","aura-e-bash-analysis.1925f79309":"command","aura-e-bash-analysis.0f3802314d":"argument","aura-e-bash-analysis.fe96dd3975":"operator","aura-e-bash-analysis.ac30c66af4":"quoted string","aura-e-bash-analysis.71b3f0bbe7":"runs","aura-e-bash-analysis.bf31c52c32":"safe","aura-e-bash-analysis.df88b84d81":"blocked","aura-e-bash-analysis.860360acc7":"verdict","aura-e-bash-analysis.2840ba1ca5":"Structure decides, not a list of strings.","aura-e-build-profiles.717e14ecef":"Core loop, optional petals","aura-e-build-profiles.e0e0d1d28c":"profiled","aura-e-build-profiles.f302aa6fc3":"a profile selects a set","aura-e-build-profiles.29d4db0977":"web intelligence","aura-e-build-profiles.b8366bdeb8":"parsing and RAG","aura-e-build-profiles.2b5856359b":"sandbox variants","aura-e-build-profiles.c242f8bba1":"coordination","aura-e-build-profiles.bdb63daa1a":"a deployment profile selects a set without changing the loop contract","aura-e-build-profiles.75d0a84162":"the petals vary","aura-e-build-profiles.5421e683c7":"the loop contract holds","aura-e-build-profiles.8d8abe9b5f":"core loop contract","aura-e-build-profiles.5d45a009b0":"profile","aura-e-build-profiles.61f427c2fa":"in profile","aura-e-build-profiles.93102f727d":"not built","aura-e-build-profiles.5c4821749c":"minimal","aura-e-build-profiles.f410e0466a":"standard","aura-e-build-profiles.52e6d8ab88":"full","aura-e-build-profiles.e6a0f9c032":"The petals vary, the loop contract holds.","aura-e-change-isolation.c70c548224":"Three recovery layers","aura-e-change-isolation.e4e5f91807":"layered","aura-e-change-isolation.b37ebb16c1":"three timescales","aura-e-change-isolation.5c528ebc85":"checkpoint","aura-e-change-isolation.94449c5bf4":"worktree","aura-e-change-isolation.5819778898":"Git","aura-e-change-isolation.3391ceab98":"checkpoints undo live, worktrees isolate, Git is durable history","aura-e-change-isolation.f7d91370c3":"finer than a commit","aura-e-change-isolation.3aa1bddb4f":"not a replacement for Git","aura-e-change-isolation.aacd3103f3":"scope","aura-e-change-isolation.5c9a2a9981":"recovery reach","aura-e-change-isolation.c20dd35672":"current turn","aura-e-change-isolation.bc733e3eb4":"one keystroke back","aura-e-change-isolation.92b5278042":"a parallel branch","aura-e-change-isolation.58aed36fc2":"throw the branch away","aura-e-change-isolation.320017a45d":"the whole project","aura-e-change-isolation.c81cb3fb98":"revert a commit","aura-e-change-isolation.0af4b9930b":"each layer contains the one before it","aura-e-change-isolation.3e9af0486e":"Each layer contains the one before it.","aura-e-circuit-cache.c4651476ca":"One circuit, four states","aura-e-circuit-cache.1b84995dfa":"isolated","aura-e-circuit-cache.f12a69014c":"per-tool windows","aura-e-circuit-cache.ea88fbaa99":"closed","aura-e-circuit-cache.5fc7e38bff":"open","aura-e-circuit-cache.2e86978701":"half-open","aura-e-circuit-cache.e3a96db810":"a cache entry invalidates after a patch touches its files","aura-e-circuit-cache.8efa299af0":"no retry storm","aura-e-circuit-cache.95fb2286f9":"no repeated reads","aura-e-circuit-cache.d9bab43240":"five failures trip the breaker","aura-e-circuit-cache.1e3d1131af":"cooldown before a probe","aura-e-circuit-cache.6122ce0a8b":"one probe succeeds","aura-e-circuit-cache.c54dbca695":"response cache","aura-e-circuit-cache.d7d390bd9e":"hit","aura-e-circuit-cache.ae8dcf468e":"invalidated","aura-e-circuit-cache.bbb3aea761":"closed again","aura-e-circuit-cache.816d304761":"Five failures trip the breaker.","aura-e-close.4f5f94d2b4":"What the architecture stands on","aura-e-close.100ec4462d":"evidence","aura-e-close.4beed4ad6f":"the engineer band","aura-e-close.aa8954f661":"Rust-native single binary","aura-e-close.fd4480a851":"dual-loop with Guardian and judge","aura-e-close.368df3249c":"fifteen-stage pipeline","aura-e-close.0e3fdf0879":"BitRank memory recall","aura-e-close.712b9a6e6d":"BLAKE3 hash-chained audit","aura-e-close.1ca5ee0009":"MCP stdio JSON-RPC 2.0","aura-e-close.9080b912fc":"measured size and source-count figures belong in a revalidated build card","aura-e-close.57eefa39c6":"a control loop","aura-e-close.1b91787369":"not a script with confidence","aura-e-config-layers.2890011254":"Four layers, one value","aura-e-config-layers.e8e2ace14f":"merged","aura-e-config-layers.afc55a5797":"a live effective diff","aura-e-config-layers.1c4ed16307":"compiled defaults","aura-e-config-layers.fbf553a898":"user config","aura-e-config-layers.8acd7f1850":"project config","aura-e-config-layers.c6e454d960":"environment","aura-e-config-layers.bb5f1cf84e":"a live diff shows which layer supplied each effective value","aura-e-config-layers.3467acb8b8":"layers merge by key","aura-e-config-layers.84ab21926d":"hot reload keeps the session","aura-e-config-layers.8208cc5b91":"precedence, low to high","aura-e-config-layers.a55d2f468c":"effective values","aura-e-config-layers.0b1e95cfd9":"from","aura-e-config-layers.d6df1ab7ac":"setting","aura-e-context-budget.11c4f1dac5":"A meter crosses thresholds","aura-e-context-budget.c072e8329e":"bounded","aura-e-context-budget.a2d630393a":"staged compaction","aura-e-context-budget.66c495a249":"summarise","aura-e-context-budget.7aa0bb99a2":"prune stale output","aura-e-context-budget.0092924130":"retain file awareness","aura-e-context-budget.500ddd61e4":"record the event","aura-e-context-budget.7d05ba3151":"the working set stays bounded rather than growing without limit","aura-e-context-budget.98eea94efe":"compaction changes behaviour","aura-e-context-budget.7a520eef7e":"so it is recorded","aura-e-context-budget.95e08528b8":"context window","aura-e-context-budget.096bc717a8":"in use","aura-e-context-budget.a81b09d952":"notice","aura-e-context-budget.4f44e2cffa":"compact","aura-e-context-budget.9a93801087":"hard limit","aura-e-context-budget.eb821104d5":"staged actions","aura-e-context-budget.8dd6a0a6da":"kept in full","aura-e-context-budget.812d4dd696":"dropped first","aura-e-event-bus.4a2319e746":"One event, six observers","aura-e-event-bus.bda4b1c3ce":"typed","aura-e-event-bus.02b8549d17":"pub and sub","aura-e-event-bus.9d57875196":"UI","aura-e-event-bus.7876153ada":"audit","aura-e-event-bus.966b973401":"metrics","aura-e-event-bus.6809e8745e":"Guardian","aura-e-event-bus.11633d4b96":"task state","aura-e-event-bus.ff432b467f":"extensions","aura-e-event-bus.2610341500":"an event enters the bus and fans out by type name","aura-e-event-bus.5394dc99d0":"state changes once","aura-e-event-bus.ad2c7c54d4":"the interested observe","aura-e-event-bus.edc1727a9d":"one typed event","aura-e-event-bus.f61e492790":"published once","aura-e-event-bus.14183681f3":"renders the diff","aura-e-event-bus.0ec31a1b34":"appends a record","aura-e-event-bus.a0e215e8b0":"counts the step","aura-e-event-bus.680e18c950":"checks for loops","aura-e-event-bus.5c85ab4e6f":"advances the plan","aura-e-event-bus.4592dd12be":"notifies plugins","aura-e-extension-files.cfe742bea8":"A file tree to a DAG","aura-e-extension-files.4399bca8d3":"reviewable","aura-e-extension-files.03504ca473":"agents are files","aura-e-extension-files.e7052aeb5d":"agents","aura-e-extension-files.816f2b87d3":"skills","aura-e-extension-files.3b5ad64a06":"prompts","aura-e-extension-files.a5a3470a97":"workflows","aura-e-extension-files.a738bccafb":"the tree opens into an effective agent definition and a workflow DAG","aura-e-extension-files.7a35d48064":"the process is versioned","aura-e-extension-files.6ed8e5a639":"hot reload updates the run","aura-e-extension-files.7d98ad90ac":"repository","aura-e-extension-files.80fe385821":"effective agent","aura-e-extension-files.899531e0f8":"workflow","aura-e-extension-files.3a9f47f2c2":"hot reload","aura-e-extension-files.789a7ffe60":"resolved from files","aura-e-goal-judge.177b83a0a5":"Two lanes, one verdict","aura-e-goal-judge.8f75a2be14":"evaluated","aura-e-goal-judge.c333682d6e":"deterministic first","aura-e-goal-judge.4d978452b9":"substring","aura-e-goal-judge.3fa7a42ea8":"regular expression","aura-e-goal-judge.a53be2595e":"file exists","aura-e-goal-judge.b30fe30bf0":"test pass","aura-e-goal-judge.1c3ef1577c":"interpretive","aura-e-goal-judge.e289ea65f7":"the deterministic lane runs first, the model lane only when needed","aura-e-goal-judge.07fa9ec5b6":"exact inputs","aura-e-goal-judge.fa2b13c073":"satisfied, unsatisfied, inconclusive","aura-e-goal-judge.a229e290ce":"deterministic lane","aura-e-goal-judge.c4ad9c54f5":"interpretive lane","aura-e-goal-judge.a34b2d93b4":"satisfied","aura-e-goal-judge.77579aa69c":"unsatisfied","aura-e-goal-judge.5e62d298da":"inconclusive","aura-e-goal-judge.140f86aae5":"input","aura-e-goal-judge.860360acc7":"verdict","aura-e-goal-judge.b13c07f77d":"the model lane runs only when the deterministic lane cannot decide","aura-e-goal-judge.56d6b14f65":"The model lane runs only when needed.","aura-e-guardian.1a1c05c3ae":"A halo around both loops","aura-e-guardian.874e70e6ab":"watching","aura-e-guardian.2f7f866bcf":"three detectors","aura-e-guardian.c0ac484241":"repeat","aura-e-guardian.6e1c6c9e2c":"stall","aura-e-guardian.81e4a5523e":"budget","aura-e-guardian.27589c6de1":"one repeated grep sequence triggers a corrective hint","aura-e-guardian.2193da814e":"the agent is not its only judge","aura-e-guardian.d0792e8828":"the loop has an observer","aura-e-guardian.b38b99bb1c":"outer and inner loops","aura-e-guardian.332ac77e06":"same call, N times","aura-e-guardian.f4f31a3dae":"no new state observed","aura-e-guardian.523a135dd8":"tokens or time exceeded","aura-e-guardian.794a9d5227":"corrective hint issued","aura-e-guardian.e876a71250":"you have run grep five times, try reading the file","aura-e-inner-loop.00826e4b4a":"A step and a correction","aura-e-inner-loop.c072e8329e":"bounded","aura-e-inner-loop.80237dd10a":"one action at a time","aura-e-inner-loop.a7afddb682":"read","aura-e-inner-loop.f8bfc15dde":"steer","aura-e-inner-loop.d75b3b5282":"patch","aura-e-inner-loop.4991ad4705":"a steering message between two actions changes the second","aura-e-inner-loop.8638f86a86":"observed output","aura-e-inner-loop.248dacd762":"not expected output","aura-e-inner-loop.5688227738":"execution gate","aura-e-inner-loop.e25f2046da":"pending action","aura-e-inner-loop.a3704ea5ab":"after steering","aura-e-inner-loop.a52101887e":"one at a time","aura-e-inner-loop.e5fd9cfe0e":"done","aura-e-inner-loop.e9624168e5":"in gate","aura-e-inner-loop.efcc77141d":"queued","aura-e-loop-topology.15a054639a":"Goal to finish or replan","aura-e-loop-topology.3c49d9cc3c":"running","aura-e-loop-topology.15a650b843":"the model is one node","aura-e-loop-topology.db9a022b75":"goal","aura-e-loop-topology.c8114c0767":"outer loop plans","aura-e-loop-topology.07c6262b30":"inner loop executes","aura-e-loop-topology.1563ede556":"observed result","aura-e-loop-topology.d7dea0ce08":"steering and policy","aura-e-loop-topology.71035612d0":"Guardian feedback","aura-e-loop-topology.22fa376ee1":"goal judge","aura-e-loop-topology.f7dc07550a":"finish or replan","aura-e-loop-topology.227af63371":"the active state reads test failed, replan 2, goal 3 of 4","aura-e-loop-topology.296c120e7e":"the model participates","aura-e-loop-topology.fe3a05266e":"it does not own the loop","aura-e-mcp-extensions.41410a82a4":"Handshake to audit","aura-e-mcp-extensions.6248086ba3":"registered","aura-e-mcp-extensions.1eee733d35":"one trust boundary","aura-e-mcp-extensions.5c477ce586":"typed handshake","aura-e-mcp-extensions.44ce002b8a":"registry insertion","aura-e-mcp-extensions.835886a396":"permission assignment","aura-e-mcp-extensions.c98699e7c2":"tool execution","aura-e-mcp-extensions.17e13b0a7b":"audit append","aura-e-mcp-extensions.358fc15724":"the remote server behaviour remains an external boundary","aura-e-mcp-extensions.640cb70d41":"discover more tools","aura-e-mcp-extensions.8f130f6488":"keep one boundary","aura-e-mcp-extensions.56c2f76475":"Aura process","aura-e-mcp-extensions.c540ce64bc":"remote MCP server","aura-e-mcp-extensions.475fd00944":"trust boundary","aura-e-memory.19b9205d11":"A correction ranks forward","aura-e-memory.c192bc980a":"recalled","aura-e-memory.5a73073370":"a visible budget","aura-e-memory.6e390bdd9e":"stored in session one","aura-e-memory.7c8c51ee76":"ranked for session two","aura-e-memory.b3dbdbd11b":"injected under budget","aura-e-memory.623ea9b38d":"forgotten on request","aura-e-memory.73de390642":"deterministic relevance and BitRank over a bounded index, FTS5 fallback","aura-e-memory.0082de6a1a":"inspectable and removable","aura-e-memory.5f8450f390":"not provider-side memory","aura-e-memory.fbc259d1f7":"capture","aura-e-memory.8855ea7c21":"project store","aura-e-memory.a2443685ed":"next prompt","aura-e-memory.f4e91f3e65":"relevance","aura-e-memory.72c5b95219":"memory budget","aura-e-memory.fb5246f07f":"correction","aura-e-orchestration.7db945a529":"Four patterns, one ledger","aura-e-orchestration.f9fff6a815":"coordinated","aura-e-orchestration.b2b2e74812":"named aggregation","aura-e-orchestration.25dd7d521e":"chains","aura-e-orchestration.1a92520138":"parallel","aura-e-orchestration.4629383656":"teams","aura-e-orchestration.248a20b62e":"background","aura-e-orchestration.e6c6d201af":"two agents contend for one file and one claim is deferred","aura-e-orchestration.a7fb28d5ce":"concurrency is easy","aura-e-orchestration.03252368b5":"shared code is the work","aura-e-orchestration.7a96b4f71e":"work ledger","aura-e-orchestration.0608c40546":"agent","aura-e-orchestration.3150ecd5e0":"path","aura-e-orchestration.013872e31d":"claim","aura-e-orchestration.2c03439596":"held","aura-e-orchestration.0db493d58e":"deferred","aura-e-orchestration.01c1c0edf1":"output of one feeds the next","aura-e-orchestration.4d09daeea8":"fan out, join on completion","aura-e-orchestration.3d991f15cd":"a lead delegates to specialists","aura-e-orchestration.ff209d99aa":"detached, polled for results","aura-e-outer-loop.896ae50b5b":"The objective ring","aura-e-outer-loop.114d2c4f93":"owning","aura-e-outer-loop.26e96c7d34":"plan versions and criteria","aura-e-outer-loop.bed97175b0":"plan","aura-e-outer-loop.39ae89e0a1":"execute","aura-e-outer-loop.d1c10fb0e6":"judge","aura-e-outer-loop.5316299897":"continue or replan","aura-e-outer-loop.089297cee1":"a tool result invalidates the plan without discarding the objective","aura-e-outer-loop.b735e57228":"the objective survives","aura-e-outer-loop.ed4bd59269":"longer than one turn","aura-e-outer-loop.e6ace012da":"goal criteria","aura-e-outer-loop.9b0cb0979a":"plan history","aura-e-outer-loop.8062c23e93":"session expiry handled","aura-e-outer-loop.1a4d34a42c":"existing tests pass","aura-e-outer-loop.40f007f5d5":"no new lint errors","aura-e-outer-loop.efd19bd226":"objective held across turns","aura-e-outer-loop.4105ad7a46":"first plan, wrong","aura-e-outer-loop.ae5ff1af0c":"replanned after failure","aura-e-outer-loop.4ae3e6baa7":"The objective persists while the plan revises.","aura-e-output-filter.b2a834c727":"Raw output to fenced context","aura-e-output-filter.75c7e3a406":"filtered","aura-e-output-filter.689aa03bd7":"data, not instruction","aura-e-output-filter.a3dd8a5de5":"ANSI removed","aura-e-output-filter.2ad5e81be9":"web content fenced","aura-e-output-filter.78b38c4e0b":"injection flagged","aura-e-output-filter.ae078841dc":"secrets redacted","aura-e-output-filter.cdccf82d04":"the model never receives the raw external content","aura-e-output-filter.15688d02bb":"untrusted stays untrusted","aura-e-output-filter.8c2f3e8e0c":"fencing is not trust","aura-e-output-filter.6acd5085bd":"raw tool output","aura-e-output-filter.38e30072e2":"filtered context","aura-e-output-filter.9a58db3523":"filtered before the model sees it","aura-e-permission-matrix.43ed6dce4b":"Tools across four layers","aura-e-permission-matrix.026ab2fab0":"resolved","aura-e-permission-matrix.f7efcf8e2e":"always, ask, or never","aura-e-permission-matrix.98f54143ab":"project","aura-e-permission-matrix.12dea96fec":"user","aura-e-permission-matrix.fcbdc4c271":"session","aura-e-permission-matrix.c6e454d960":"environment","aura-e-permission-matrix.27714c9c68":"an out-of-scope path is routed to approval, not silently widened","aura-e-permission-matrix.50796d635b":"a capability matrix","aura-e-permission-matrix.c86d9c0e67":"not one global switch","aura-e-permission-matrix.1937c4c28f":"tool","aura-e-permission-matrix.6656018ac9":"always","aura-e-permission-matrix.1c8f09270f":"ask","aura-e-permission-matrix.85777c03b7":"never","aura-e-permission-matrix.0b214c456e":"resolved value","aura-e-permission-matrix.4d2a588afc":"path outside project root","aura-e-quality-ci.24d5ee5d4f":"Same policy, two surfaces","aura-e-quality-ci.18cd42d86d":"gated","aura-e-quality-ci.f205411f8e":"failure as state","aura-e-quality-ci.4ab6e45839":"interactive TUI","aura-e-quality-ci.b67626b7bb":"CI runner","aura-e-quality-ci.82de00eba8":"structured output","aura-e-quality-ci.3ef9250549":"loop feedback","aura-e-quality-ci.b79334f258":"both invoke the same goal and quality policy and produce comparable events","aura-e-quality-ci.00f2398b69":"evidence, not proof","aura-e-quality-ci.ac2f995a8e":"policy decides what blocks","aura-e-quality-ci.d8a0c27467":"shared goal and quality policy","aura-e-quality-ci.c6b4353aa1":"comparable events","aura-e-quality-ci.1b4981a561":"failure returns as state","aura-e-quality-ci.6386f0e241":"A failed gate returns as state.","aura-e-runtime-modules.a2387145a1":"One binary, grouped modules","aura-e-runtime-modules.513fd31089":"separated","aura-e-runtime-modules.255c841977":"by loop responsibility","aura-e-runtime-modules.c99a2bcf3e":"Observe","aura-e-runtime-modules.ae2f98a099":"Plan","aura-e-runtime-modules.138a104b73":"Act","aura-e-runtime-modules.ea1d3df298":"Control","aura-e-runtime-modules.a725020675":"State","aura-e-runtime-modules.8cde59838c":"Coordinate","aura-e-runtime-modules.4e9f7a31ee":"Present","aura-e-runtime-modules.1c54132b8e":"Record","aura-e-runtime-modules.602f6be9dc":"modules are separated by typed contracts, not shared mutable state","aura-e-runtime-modules.6a1f36237f":"one process","aura-e-runtime-modules.398ae9f6cf":"independently testable","aura-e-runtime-modules.d5c0b7e9f2":"tools and events in","aura-e-runtime-modules.afd31a3fa6":"outer loop replans","aura-e-runtime-modules.b6d209aee2":"inner loop, one step","aura-e-runtime-modules.cb033bb0c5":"steering and permissions","aura-e-runtime-modules.68f9353f5a":"tasks, checkpoints, memory","aura-e-runtime-modules.695cd841b8":"agents and file claims","aura-e-runtime-modules.cc993d4e28":"TUI and diff views","aura-e-runtime-modules.99c64c8bb8":"audit and metrics","aura-e-runtime-modules.83076edf09":"one Rust binary","aura-e-runtime-modules.9990357bc3":"Modules meet only at the typed bus.","aura-e-steering.95dbb05217":"Interrupt between calls","aura-e-steering.98aadb3708":"live","aura-e-steering.d357e856e4":"the step is replaceable","aura-e-steering.c82e3d7279":"stream","aura-e-steering.f8bfc15dde":"steer","aura-e-steering.b61646f016":"abort","aura-e-steering.daaad33627":"wait","aura-e-steering.591160c88d":"the pending step is replaced and the audit records the event","aura-e-steering.63e70712d1":"control stays live","aura-e-steering.d8bdbe8d9c":"the prompt is not final authority","aura-e-steering.018fd3d551":"response stream","aura-e-steering.a5fc4a9fc0":"pending tool call","aura-e-steering.8701b1f1ff":"replaced before execution","aura-e-steering.27d37adcbe":"audit records the steering event","aura-e-steering.31e67ae584":"context stays warm","aura-e-tool-pipeline.f0aa065825":"Fifteen stages, one call","aura-e-tool-pipeline.17e214ac4f":"staged","aura-e-tool-pipeline.57cd86f159":"the trust boundary","aura-e-tool-pipeline.436fe6a365":"normalise","aura-e-tool-pipeline.e76dce35ea":"circuit breaker","aura-e-tool-pipeline.aacd3103f3":"scope","aura-e-tool-pipeline.a7ca68174f":"enablelist or denylist","aura-e-tool-pipeline.6d244f5836":"permission","aura-e-tool-pipeline.0be0a65fc9":"bash analysis","aura-e-tool-pipeline.36a6cb6941":"file policy","aura-e-tool-pipeline.5c528ebc85":"checkpoint","aura-e-tool-pipeline.b03592806e":"cache","aura-e-tool-pipeline.39ae89e0a1":"execute","aura-e-tool-pipeline.5d3b463f65":"cache update","aura-e-tool-pipeline.49b47e9790":"output filter","aura-e-tool-pipeline.faa83d7206":"sanitise and redact","aura-e-tool-pipeline.7876153ada":"audit","aura-e-tool-pipeline.3408a66399":"breaker update","aura-e-tool-pipeline.019ce43c40":"a patch call and an MCP call each run the full pipeline","aura-e-tool-pipeline.c46d33ba06":"the tool is one stage","aura-e-tool-pipeline.658fd4ef0e":"the pipeline is the boundary","aura-e-tool-pipeline.cbec25971a":"patch call","aura-e-tool-pipeline.8baebd9edc":"MCP call","aura-e-tool-pipeline.0ece5421f9":"decides","aura-e-tool-pipeline.100d94a42f":"no-op","aura-e-tool-pipeline.63edb7d672":"select a call to see which stages act","aura-e-tool-pipeline.f92a0d6b57":"pipeline stage","aura-e-tui-console.6ef54a4fb8":"Panels mapped to the loop","aura-e-tui-console.bf40af4bf8":"annotated","aura-e-tui-console.390af0a46a":"keyboard-first","aura-e-tui-console.33d7ddc264":"chat and diff","aura-e-tui-console.0046e84aef":"files and search","aura-e-tui-console.1c956bc735":"quality and goals","aura-e-tui-console.99c7005202":"audit and tasks","aura-e-tui-console.298eb8d1f9":"each panel maps to a loop responsibility","aura-e-tui-console.b49d84d38d":"a control console","aura-e-tui-console.bed2e8dea5":"not a chat window","aura-e-tui-console.0e9abd0d82":"loop responsibility","aura-e-tui-console.4f4224f44a":"observe","aura-e-tui-console.76f3b5a717":"act","aura-e-tui-console.d1c10fb0e6":"judge","aura-e-tui-console.275a700078":"record","aura-showcase.eyebrow":"Dweve platform","aura-showcase.subtitle":"Coding agent and operator assistance. Demo metrics are illustrative.","aura-showcase.pillTools":"25+ tools","aura-showcase.pillRunning":"running","aura-showcase.pillAnalysing":"analysing codebase","aura-showcase.capabilityToolsTitle":"25+ tools","aura-showcase.capabilityToolsBody":"Terminal, search, lint, test, git, and more.","aura-showcase.capabilityMemoryTitle":"Semantic memory","aura-showcase.capabilityMemoryBody":"Remembers your codebase and team context.","aura-showcase.capabilityAgentsTitle":"Multi-agent orchestration","aura-showcase.capabilityAgentsBody":"Specialised agents collaborate across concerns.","aura-showcase.guaranteeAuditTitle":"Audit trail","aura-showcase.guaranteeAuditBody":"Every step is recorded with timestamps.","aura-showcase.guaranteeGuardrailsTitle":"Guardrails","aura-showcase.guaranteeGuardrailsBody":"Policies, checks, and tests always run.","aura-showcase.guaranteeApprovalTitle":"Code changes with approval","aura-showcase.guaranteeApprovalBody":"Review diffs, request changes, final sign-off.","aura-showcase.guaranteeReplayTitle":"Deterministic replay","aura-showcase.guaranteeReplayBody":"Replay any session bit-for-bit when something needs review.","aura-showcase.workflowUnderstand":"Understand","aura-showcase.workflowUnderstandCaption":"Read retry.ts, traced timeout bug","aura-showcase.workflowPlan":"Plan","aura-showcase.workflowPlanCaption":"Extract guard + cap retries","aura-showcase.workflowImplement":"Implement","aura-showcase.workflowImplementCaption":"Patched retry.ts + types.ts","aura-showcase.workflowTest":"Test","aura-showcase.workflowTestCaption":"28 tests, 94% coverage","aura-showcase.workflowVerify":"Verify","aura-showcase.workflowVerifyCaption":"Running lint & typecheck...","aura-showcase.workflowAudit":"Audit","aura-showcase.workflowAuditCaption":"Awaiting summary write-up","aura-showcase.footer":"Autonomous agents that write code and keep receipts","aura-showcase.testsPassing":"passing","aura-showcase.testsFailing":"failing","aura-showcase.modified":"modified","aura-showcase.af0854de67":"Aura","aura-showcase.73989d9c59":"Running","aura-showcase.f9e94338d0":"Analyzing codebase","aura-showcase.d7a484140f":"Workflow","aura-showcase.287fda8114":"Unified","aura-showcase.80e13549b4":"Coverage","aura-showcase.b71cc78b34":"Extracted isRetryableError","aura-showcase.c37a8a9e2b":"to handle\n                    network timeouts, 5xx responses, and idempotent-safe\n                    conditions. Pure helper, fully unit-tested.","aura-tech-middles.7fba7d244f":"Hot path","aura-tech-middles.1be47ef71c":"Cross-cutting","aura-tech-middles.92096d78df":"Ingress","aura-tech-middles.8e05a902ed":"Egress","aura-tech-middles.49a66c994d":"Builtin agents","aura-tech-middles.a60792e996":"Outer loop","aura-tech-middles.0dfd4db698":"Inner loop","aura-tech-middles.bbd88bff92":"Incoming request","aura-tech-middles.a618b4be8d":"Query","aura-tech-middles.a4942c26d0":"SELECT","aura-tech-middles.2cb479aa15":"* FROM","aura-tech-middles.1c255b91e7":"WHERE","aura-tech-middles.2164bde64d":"ORDER BY","aura-tech-middles.82dd2cdf36":"Block","aura-tech-middles.271973aefe":"xMidYMid meet","core-extras.96d330537a":"Base IR","core-extras.bee831a169":"Substrate","core-extras.61a0822826":"Apps on Core","core-extras.15438cc098":"not supported","core-extras.ad565d9d01":"Feature","core-extras.0155bf03e5":"Segment legend","core-extras.8b7110078e":"Algorithm groups by data type","core-extras.25ab4276a6":"Scrollable capability matrix","page-breadcrumb.c766e66518":"Breadcrumb","page-toc.7e439c353e":"On this page","product-aura.68a4194227":"Docs","product-aura.8106c1a1cb":"Talk to engineering","product-aura.36ffd31f95":"See Loom's reasoning layer","product-aura.859ca6c242":"Request access","product-aura.d0ed7c99e7":"Aura ships as a single static binary with no runtime dependencies. Enterprise support, custom development, and training available from Dweve.","product-aura.243d064a8c":"Built for review.","product-aura.f9310a86ac":"Built in Rust.","product-aura.90e40d5043":"Get started","product-aura.2dbad2ed37":"# resolved at runtime; AURA_MODEL overrides project","product-aura.1413425f08":"merged, hot reload on save","product-aura.da8b02ec1a":".aura/config.toml (resolved)","product-aura.d443a11855":"Environment","product-aura.3278a000b9":"Project config","product-aura.95ee1ab0f5":"User config","product-aura.5f6eb8ef37":"Built-in defaults","product-aura.53c11ee14f":"Aura, Technical","product-aura.b0c118d336":"Highest layer wins. Always.","product-aura.a18ec06972":"Project, user, env.","product-aura.85e5f56bd5":"YOUR LAYER","product-aura.c342fcb86a":"Boots safely without touching a file.","product-aura.3a5d5665e8":"Sensible, conservative.","product-aura.41a2cdb105":"BUILT-IN DEFAULTS","product-aura.3c095f7986":"Per-project, per-machine, per-env","product-aura.2d1a43c1c1":"DEFAULTS vs YOUR OVERRIDES","product-aura.b97b575a71":"WATCHED, HOT-RELOAD","product-aura.d07fe5750f":"AURA_* WINS","product-aura.8a45b914e2":"4 MERGED LAYERS","product-aura.b0872226c3":"Anything you can set in TOML, model, per-tool permission levels, audit log path, named profile, you can pin per project, override per machine, or flip per env var. Touch any of those files, the agent watches them and rebuilds its system prompt without restarting the session. No reboot, no lost context.","product-aura.c0535ff18b":"Aura resolves config across four layers, built-in defaults, your user-level `~/.dweve/config.toml`, the project's `.aura/config.toml`, and any `AURA_*` environment variable. They merge per key, with each layer overriding the one beneath it; environment variables sit on top so a single export can flip Aura's behaviour for one CI job, one branch, one demo.","product-aura.66ee57b2b2":"Env always wins.","product-aura.9d672cac7c":"Four-layer TOML.","product-aura.754164850f":"Configuration","product-aura.3d700c1ece":"You read diffs against the project spec…","product-aura.8076d23ccd":"# Reviewer","product-aura.d6d81b30a7":"success: tests-pass && lints-clean","product-aura.3df5679740":"tools: [diff, grep, tests, audit]","product-aura.b03d145093":"model: \"claude-sonnet\"","product-aura.016ed864da":"role: \"code review, before commit\"","product-aura.345ce28bf3":"name: \"reviewer\"","product-aura.4c6f97dc45":"frontmatter, md+yaml","product-aura.e1b87e366c":"Prompt rebuilds live","product-aura.f870feb7b9":"Edit a file","product-aura.b57ef4392f":"Hot reload, CLAUDE.md / .aura/*","product-aura.d7abb1f1b1":"Rust trait API, tools, slash, events","product-aura.adb1c4234d":"Run a DAG: debug, feature, review","product-aura.9fe25a9fa5":"Conditionally injected prompt fragments","product-aura.8fdd1a59ee":"List or switch agents, project / user / builtin","product-aura.06833bde6c":"HOT","product-aura.25352ed4ea":"Browse, edit, reload","product-aura.9e2326ff4c":"EXTENSION COMMANDS","product-aura.a292818064":"HOT RELOAD","product-aura.29371ac4ba":"DAG WORKFLOWS","product-aura.d060c443dc":"BUILT-IN AGENTS, 6","product-aura.be9a2015f1":"Agents, skills, plugins and workflows are markdown + YAML on disk. Six built-in agents ship with Aura; project, user and global tiers are merged at startup. Edit a file, the agent rebuilds its prompt without restarting.","product-aura.6d51004da0":"YAML frontmatter. Hot reload.","product-aura.362c66c957":"Markdown agents.","product-aura.d9d8a5a360":"Extension system","product-aura.15003bd9a4":"audit, CVEs","product-aura.fa1703dd78":"Audit","product-aura.a4d6f5e89d":"examples run","product-aura.6552c6f5f6":"Doc-tests","product-aura.1d262c199b":"+ integration","product-aura.39fdec1194":"Tests","product-aura.c2f3e610ef":"Compile","product-aura.5e151c4578":"warns promotable","product-aura.fb5fb79636":"Lint","product-aura.041a5dec48":"Format","product-aura.b5451d9a73":"in .aura/quality.toml","product-aura.8ca0f97e38":"Promote warns to gates","product-aura.f416412b8f":"cargo-audit CVE scan","product-aura.ceb5b19a94":"unit + integration + doc","product-aura.b0f2eede23":"lint pass, warns promotable","product-aura.90826036c9":"rustfmt formatting check","product-aura.076a4d3fcd":"gates, fail fast and fix in place","product-aura.af99a5c898":"6 STAGES","product-aura.d7f3e24e66":"run in sequence on /quality","product-aura.2ec99b89e1":"QUALITY GATES","product-aura.f161ee43b6":"`/quality` runs fmt, clippy, compile, tests, doc-tests, and a security audit in sequence. Failures include stack traces and diff context. Warnings are non-blocking by default; you can promote them to gates per project.","product-aura.e31b222e3e":"One keystroke.","product-aura.18f158ab5d":"Six gates.","product-aura.66e2191d8c":"Quality pipeline","product-aura.dc87274447":"Stdio JSON-RPC 2.0, managed subprocess, same permission and audit pipeline as builtins.","product-aura.94cbffb24e":"MCP server","product-aura.92f627e611":"EXTERNAL","product-aura.016ad99e5a":"MCP client","product-aura.14afd82a7f":"AURA","product-aura.3d98789ffb":"No bespoke MCP code in Aura","product-aura.ec22796a4c":"Common to every Dweve product","product-aura.90d17b70e2":"stdio, JSON-RPC 2.0 framing","product-aura.7f9786f549":"structured logs over the bus","product-aura.f686d5056d":"server-initiated LLM calls","product-aura.e3749e62c8":"reusable prompt templates","product-aura.8f55c43888":"discovered, registered, gated","product-aura.332fb6ffa5":"read, subscribe, list","product-aura.61461492c5":"opt-in per surface","product-aura.dca9368ef1":"capability flags, negotiated per server","product-aura.1b4306be38":"TYPED","product-aura.0a215ab487":"MCP CAPABILITY SURFACE","product-aura.260245866c":"TYPED CAPABILITIES","product-aura.1420fc5684":"STDIO, JSON-RPC 2.0","product-aura.af0440b9bf":"MCP servers are declared in Aura's config: command, arguments, environment. On session start, Aura spawns them as managed subprocesses, runs the typed capability handshake from `dweve-protocol::mcp::capability`, and registers the discovered surface in the same tool registry the builtins live in. Resources, tools, prompts, sampling and logging capabilities all flow through the same typed message bus from `dweve-protocol::mcp::message`. External tools aren't trusted by default, they inherit per-tool permission levels, audit logging, PII filtering and circuit-breaker protection.","product-aura.5f8a78e893":"Aura's MCP client is built on `dweve-protocol::mcp`, the typed MCP message, capability, transport and tool surface that the rest of Dweve also uses. Connect to any MCP server over stdio JSON-RPC 2.0, negotiate capabilities, and surface its tools / prompts / resources alongside Aura's builtins. Same permission gate, same audit trail, same circuit breaker.","product-aura.e22c750980":"on Dweve's own stack.","product-aura.de09bded79":"Model Context Protocol","product-aura.c53f9924c6":"MCP integration","product-aura.49798f4232":"shared state","product-aura.aa3a621015":"tmux, zellij","product-aura.a92a3c2830":"Agents share a task board, exchange messages via the event bus, and enforce quality gates. Cross-agent work ledger tracks file-level claims to prevent conflicts.","product-aura.01e41d1104":"Coordinated groups","product-aura.b4a89de81b":"fan-out / fan-in","product-aura.83369a12f2":"4 strategies","product-aura.1d384ffc6e":"Spawn multiple agents simultaneously with the same input. Aggregation strategies: unanimous (all agree), majority (most common), first-success (fastest valid), or custom merge.","product-aura.21c8936cdd":"Concurrent execution","product-aura.a3564e82b9":"5 builtin","product-aura.73b98d56aa":"step → step","product-aura.dcca77903e":"Multi-step execution where each step's output feeds into the next. Variable substitution with Jinja-like syntax. Built-in chains for debug, feature, optimisation, refactor, and review.","product-aura.2216ea3c93":"Sequential workflows","product-aura.06fdf9d39d":"Hot-loaded","product-aura.1cbbcf22a4":"Drop a .md file","product-aura.e1139f7099":"file-level claim tracking","product-aura.0ea1055e09":"long-running, abort handles","product-aura.6db7757469":"task board, message bus","product-aura.9eee485cf4":"unanimous / majority / first","product-aura.535280424b":"sequential, jinja vars","product-aura.271d205d07":"plus your own","product-aura.be16892722":"built-in agents, merged across tiers","product-aura.6990f01ad9":"LIVE","product-aura.643b03ff1a":"four orchestration patterns","product-aura.5fb4b75091":"AGENT REGISTRY","product-aura.a443f56d90":"WORK LEDGER, NO CONFLICTS","product-aura.5fd319f96b":"YAML FRONTMATTER","product-aura.8ee25d95fb":"4 PATTERNS","product-aura.0f515082c1":"Chains are defined as markdown files with YAML frontmatter, a name, description, ordered steps. Each step names an agent, specifies a goal, and may reference the output of previous steps through Jinja-like variables. Success criteria declare what counts as completion (substring match, regex, file existence, test pass). Built-in chains cover debug, feature implementation, optimisation, refactor and review. Drop a markdown file in the chains directory to define a custom one, no rebuild.","product-aura.7480cd1547":"Aura's agent registry supports four orchestration patterns. Chains execute agents sequentially with variable substitution. Parallel runs agents concurrently with result aggregation. Teams coordinate multiple agents with shared state and messaging. Background tasks run independently with abort handles and status tracking.","product-aura.3f2ba51d80":"background tasks.","product-aura.e40f48f8a9":"Chains, parallel, teams,","product-aura.771ec1dc79":"Multi-agent orchestration","product-aura.1232e98980":"context trimmed","product-aura.6d79034fa7":"Three-tier compactor merged stale tool output at high utilisation.","product-aura.dda7539f59":"lifecycle, compaction","product-aura.ed5846db5d":"a015, 7c93, 3e6f, d28b","product-aura.c36a9ab37b":"Classifier picked claude-sonnet for moderate-complexity task.","product-aura.3fc5fa433d":"route, model_selected","product-aura.9cce38dc01":"9e1b, 22a7, 8d50, 6b3c","product-aura.8ec4e1a21b":"142 ms","product-aura.b3a43f300e":"Patch applied to src/auth/session.rs.","product-aura.c2a73df64d":"tool, write_file","product-aura.8107c5ac81":"4f2a, b7d1, 1c83, e0a4","product-aura.caeaac6e81":"Every hash breaks","product-aura.dfa0f09d72":"Tamper any line","product-aura.c8ab169bd9":"tier 2/3, stale output merged","product-aura.68d3772d86":"a015, 7c93","product-aura.6ece715413":"claude-sonnet, moderate","product-aura.667b64634c":"9e1b, 22a7","product-aura.00106794d9":"4f2a, b7d1","product-aura.a40bc97845":"entries verified, 0 broken","product-aura.66bb2fab8a":"VALID","product-aura.b42eed7512":"aura verify-audit","product-aura.c06d37c500":"VERIFY CHAIN","product-aura.c7efdcaa50":"BLAKE3 CHAINED","product-aura.bb183c52af":"Every event lands on its own line in an append-only JSONL file. Each line carries the BLAKE3 hash of the previous, so verifying the chain from start to current detects any modification. Not a best-effort log, a cryptographic decision journal.","product-aura.ca61a2804e":"Tamper one entry, every hash breaks.","product-aura.ef9ab16061":"JSONL + BLAKE3.","product-aura.33de865a8d":"Audit trail","product-aura.9e9f695d5b":"budget fit","product-aura.3e845acfe8":"Trim to fit context budget; lowest-scoring drop.","product-aura.f0514cac9b":"Inject","product-aura.423f4c786a":"bm25 rank","product-aura.79df59dd68":"BM25 ranks by relevance, recency, and access count.","product-aura.dd48a11495":"Rank","product-aura.d91ff796ca":"fts5 match","product-aura.fa2ae9d626":"FTS5 finds memories matching the query.","product-aura.0335207f5e":"Match","product-aura.66879fb005":"prompt inject","product-aura.4bcfe6db59":"token budget","product-aura.27a13eeeef":"WHERE memories MATCH \"auth refactor\"","product-aura.96ed2ec329":"SELECT * FROM memories","product-aura.4f2ecdb3b5":"Auto-pruned","product-aura.5758d59c50":"Per-project DB","product-aura.cbefb320ba":"Drop the lowest-scored memories until the prompt fits the model context.","product-aura.8bc7c6d3b8":"Token-budget trim","product-aura.ae5ed29057":"Combine relevance, recency, and access count into a single score.","product-aura.f0dbee2d99":"BM25 + recency","product-aura.0790b4215c":"Virtual table over the memories column, prefix + phrase queries.","product-aura.c707bc39bb":"FTS5 lookup","product-aura.12bc5f9c75":"Per request, three stages","product-aura.3891c9037c":"RETRIEVAL PIPELINE","product-aura.b3b111d31b":"BM25 RANKING","product-aura.3e4785b1c5":"SQLITE FTS5","product-aura.1746c9c286":"Memories are indexed in SQLite with an FTS5 virtual table. Each retrieval ranks by BM25, then trims to fit the prompt budget. Old, low-relevance entries get pruned automatically; frequently accessed ones are refreshed.","product-aura.1c4de673b8":"Token-budget-aware retrieval.","product-aura.be9d897bbb":"SQLite + FTS5.","product-aura.5d169e270e":"Semantic memory","product-aura.906e9f0e82":"Output filter strips ANSI codes, progress bars, spinner animations, and duplicate lines from tool output before it enters conversation history. Prevents token waste and context pollution.","product-aura.5bc9e9416e":"Output sanitisation","product-aura.77ab52bbfa":"SANITIZER","product-aura.bd50e3e49d":"Seventeen-pattern detector covering OWASP injection variants, base64-encoded smuggling, homoglyph swaps, delimiter confusion and instruction override. Suspicious content is quarantined before reaching the LLM.","product-aura.02132e9446":"Prompt injection detection","product-aura.9b79aefea3":"PATTERNS","product-aura.697ede464d":"Multi-pattern detector identifies emails, phone numbers, credit cards, API keys, national identifiers, and custom patterns. Detected values are redacted before transmission to LLM providers and stored redacted in logs.","product-aura.a6e563a99a":"PII detection and redaction","product-aura.716aef4dca":"PII","product-aura.9327735384":"Two-tier allowlist controls which paths and operations each tool can touch. Session-level allowlists override global rules so a single risky session can be loosened without permanently widening the surface.","product-aura.ab652cdfea":"Session + global allowlists","product-aura.a161919d9c":"ALLOWLIST","product-aura.abc813d634":"Glob-based ACLs restrict which files and directories each tool can access. Path containment ensures tools cannot escape the project root. Per-session allowlists override global policies.","product-aura.c379051708":"File access policy","product-aura.9da96ff81a":"FILE POLICY","product-aura.8f128de646":"Shell commands are parsed into an AST before execution. Dangerous patterns (rm -rf, pipe to shell, network exfiltration, privilege escalation) are detected and blocked. Safe commands run; unsafe commands require explicit approval.","product-aura.3a7897a59f":"Bash AST analysis","product-aura.6ae164cdb6":"BASH ANALYZER","product-aura.eee0f04cba":"YOUR CODEBASE","product-aura.a28b1d0602":"SIX MODULES, ALL ACTIVE","product-aura.2308ed0895":"Tune up, never down","product-aura.93a2385f8d":"Defaults conservative","product-aura.b1aeb83829":"ANSI / progress / dupes stripped","product-aura.b22b263d34":"prompt-injection, 17 patterns","product-aura.dc8f8379d4":"pre-LLM","product-aura.836ab097ce":"multi-pattern, emails / keys / IDs","product-aura.09f1dab95b":"session + global allowlists","product-aura.0e34bf1cd2":"per-tool file glob ACL","product-aura.c9cac8c101":"AST parse / block dangerous shell","product-aura.43c0559ee5":"modules active, 0 bypassed","product-aura.04f44d6ca6":"ALL ON","product-aura.2c016d76af":"src/security, all active","product-aura.e117fdaa64":"CONTROLS, LIVE","product-aura.16e5063462":"Defaults are conservative: PII redaction always on, prompt-injection detection running, bash commands parsed into an AST before execution, and filesystem operations contained to the project root. Turn knobs up, never quietly down. Outputs from every tool pass through an ANSI / progress-bar / duplicate-line filter before they enter conversation history, so prompt context stays clean and tokens stay focused.","product-aura.900fb85fc9":"Aura's security architecture operates at three independent layers, the tool layer (permission system, bash AST analysis), the content layer (PII detection, prompt-injection detection, content sanitisation), and the infrastructure layer (filesystem scope, session allowlist, network controls). Each is configurable per project, per session, per env.","product-aura.feaa6d8571":"at every layer.","product-aura.9f08977975":"Defence in depth","product-aura.e6148c0bfa":"Security model","product-aura.28b907cfa3":"On rate-limit or fail, retry with the next model in the chain.","product-aura.b4a100ebc4":"Fallback","product-aura.959cb4d624":"Streaming response with token + budget tracking, cooperative abort.","product-aura.df063869e1":"Stream","product-aura.61c10b64dd":"BYO","product-aura.d135ef0436":"Cheapest capable model from registry, per provider.","product-aura.2073ebce0d":"Pick model","product-aura.130d61f87e":"Score complexity: simple, moderate, complex, research.","product-aura.a16c4ed9fa":"Classify","product-aura.cebae49d6b":"Fallback chain on fail","product-aura.a12b23e2bd":"Cheapest capable model","product-aura.8d7b9e8faf":"Aider, Claude Code, Gemini, Kimi","product-aura.d93d10ff0f":"API","product-aura.7cfb3d7d52":"GLM, Kimi, Anthropic-shaped APIs","product-aura.e5744ab835":"Mistral, Codestral","product-aura.6ec472d054":"Groq, Together, DeepSeek, Fireworks","product-aura.b67a3ecea4":"Claude family, streaming, prompt cache","product-aura.4e8415a99c":"router on top","product-aura.21ea053202":"native API backends, plus CLI advisory wraps","product-aura.c3bde89f39":"BYO KEY","product-aura.7214ef704e":"BACKEND LAYER","product-aura.a0bb907008":"TOML HOT-RELOAD","product-aura.c77dec5401":"COMPLEXITY ROUTER","product-aura.6e35755b9a":"BYO KEYS","product-aura.2b82179b34":"A complexity-based router classifies every request, simple, moderate, complex or research, and picks the cheapest capable model from your registry. Models live in a single TOML under ~/.dweve. Each entry pins the name, provider, API-key environment variable, context window and complexity tag. Add a row, save, the agent hot-reloads. Fallback chains keep the session moving when a provider rate-limits or fails. Streaming responses, real-time token display, context-budget tracking and cooperative abort apply to every backend.","product-aura.37478398a5":"Aura is provider-agnostic. The backend layer in src/llm/backends ships native API clients for Anthropic Claude, Mistral and Codestral, the OpenAI-compatible API (Groq, Together, DeepSeek, Fireworks and more) and the Anthropic-compatible API (GLM, Kimi). CLI advisory backends additionally wrap Aider, Claude Code, the Gemini CLI and the Kimi CLI, so you can pull a second opinion from another agent without leaving the session. Gemini is reached through its CLI, not a native API backend.","product-aura.f64932876d":"the router picks per task.","product-aura.9bd97cc556":"Bring your own model,","product-aura.2a06f7d5be":"LLM backends","product-aura.ef99046dcb":"Sliding window tracks recent success/failure ratio per tool. When failure rate exceeds threshold, the tool is blocked for a configurable cooldown. Prevents retry storms and cascade failures.","product-aura.dc62e43d3e":"Failure isolation","product-aura.58a67475cb":"Read-only tools (read_file, glob, tree, symbols) cache results in an LRU cache keyed by arguments. Cache entries are automatically invalidated when write tools modify the relevant files.","product-aura.cb17f43a45":"LRU deterministic cache","product-aura.1a60efefd4":"Per-tool permission levels configurable globally and per-session. File access constrained by glob ACLs. Shell commands require AST-based safety analysis before execution.","product-aura.71e85e064d":"Always / Ask / Never","product-aura.92fbe9e406":"Audited every call","product-aura.d4e0d1e963":"Each tool ACL-scoped","product-aura.8d9a304fd9":"MCP servers","product-aura.8d10c693b7":"External","product-aura.9f8a2389a2":"User","product-aura.e5e429bcc9":"Data","product-aura.a8323a2a9b":"Web","product-aura.bdc1fd5d3c":"Shell","product-aura.adac69379a":"Code","product-aura.2c3cafa4db":"File","product-aura.1e282fb85b":"builtins, grows with MCP","product-aura.6ca32b1fda":"Real names from src/tools/builtins","product-aura.3fd7be348d":"TOOL CATEGORIES","product-aura.ebcb69c4e3":"CIRCUIT BREAKERS","product-aura.f7e8f28651":"LRU CACHE","product-aura.8b05af2f33":"7 CATEGORIES","product-aura.9483f780f1":"Tools span file I/O, code analysis, shell, git, web, data and user prompts. Each one passes through the same fifteen-stage pipeline, permission check, ACL scope, cache lookup, output filter, PII redactor, audit append, whether it's a builtin or an MCP server.","product-aura.55c6147c11":"Permissioned and cached.","product-aura.5d51f6711b":"25+ builtins, one pipeline.","product-aura.f88be40d34":"Tool system","product-aura.4d11d3f11f":"ONE STATIC BINARY","product-aura.4885d6a73f":"NO RUNTIME DEPS","product-aura.7f5fc4d2ae":"RUST 2021","product-aura.f5d178f7bd":"Aura is around 330 KLoC of Rust across 433 source files in src/, compiled to one static binary with no runtime dependencies. The atlas below is the real module tree by file count, ui and agents and tools carry the weight, with security, audit and memory small and sharp.","product-aura.3e608ea3fc":"measured, not estimated.","product-aura.1ab6d91b50":"433 .rs files in src/,","product-aura.a7c9035efe":"Source tree","product-aura.6862b5d306":"Background task that monitors loop health. Detects doom loops (repeated identical actions), stalls (no progress for N turns), and budget overruns (token consumption exceeding threshold). Injects corrective hints or aborts the session.","product-aura.86de7dfa18":"Watchdog","product-aura.094491ce32":"Parses LLM responses for tool calls, validates arguments against schemas, executes tools with timeout and permission checks, and formats results for the LLM. Supports mid-turn steering when results diverge from expectations.","product-aura.6c2519cd62":"Tool execution","product-aura.3579aa9156":"Maintains conversation history, tracks context budget, decides when to compact history, and handles multi-turn conversations. Coordinates goal setting and success criteria evaluation.","product-aura.be6408726f":"Session orchestration","product-aura.ea0ad3e580":"Loop components","product-aura.a2d54494ae":"Type to redirect","product-aura.b26fb61b75":"Steer mid-turn","product-aura.8291a4b5e8":"doom loops","product-aura.e1ad7c6767":"Outer, Inner, Guardian halo","product-aura.47a337bcbd":"LOOP TOPOLOGY","product-aura.5f8499faa7":"GOAL JUDGE","product-aura.3226e7c539":"GUARDIAN WATCHDOG","product-aura.e5fdca5c97":"MID-TURN STEERING","product-aura.eb598f5e39":"The outer loop runs until the session goal is achieved. On each iteration it asks the LLM to plan given the current context and goal, producing a sequence of steps. The inner loop walks through those steps one at a time, executing the tool call, adding the result to context, and checking whether the result requires mid-turn steering. If the output diverges from expectations, the LLM generates a correction that is applied immediately. After every step the Guardian watchdog inspects the context for doom loops, stalls, or budget overruns. Once all steps complete, the goal judge evaluates whether the objective has been satisfied. If not, the outer loop replans with the enriched context.","product-aura.321801388d":"Aura's agent uses a dual-loop architecture. The outer loop maintains session context, decides when a task is complete, and handles follow-up questions. The inner loop executes individual tool calls, processes responses, and steers mid-turn. A background Guardian watchdog monitors both loops for anomalous behaviour.","product-aura.0762eea955":"Guardian watches.","product-aura.999d83eda1":"Inner loop executes.","product-aura.22f953be4d":"Outer loop plans.","product-aura.556291560a":"Dual-loop reasoning","product-aura.b63df59055":"tokio async, typed bus","product-aura.ea35c6da2d":"static binary, no Python, no Node","product-aura.9cd1a2e04b":"~22 MB","product-aura.4f918f30b7":"PII, injection, bash AST","product-aura.4a634d5792":"Security layer","product-aura.3174d87eba":"GUARD","product-aura.ca2bd0ef60":"SQLite, FTS5, TOML","product-aura.a21eca395f":"Memory + sessions","product-aura.bef84bb0f5":"STATE","product-aura.d5fb8fd9bc":"cache, circuit, audit","product-aura.2d81759479":"25+ builtins, MCP","product-aura.9d0e510bd5":"TOOLS","product-aura.c8a6b030f9":"chains, parallel, teams","product-aura.1fd6a805da":"Registry","product-aura.31e78faee8":"AGENTS","product-aura.82e5710cb3":"event bus, state store","product-aura.e91506d033":"Coordinator","product-aura.6d917c2df3":"CORE","product-aura.748a66c374":"dual-loop, Guardian, routing","product-aura.28d2947423":"Orchestrator","product-aura.370515d5b1":"LLM","product-aura.f6dd0ae4f2":"tabs, diff, search, settings","product-aura.ab17073b72":"ratatui TUI","product-aura.9d57875196":"UI","product-aura.f9b21d0d58":"Async coordinator with a typed event bus","product-aura.f75fd3a884":"No runtime deps","product-aura.562fe8547f":"Modular by file tree","product-aura.7efb9d3746":"types, event bus, errors","product-aura.017056c92c":"backends, routing, stream","product-aura.d098916a7d":"builtins, MCP, cache","product-aura.0b6ddebf1f":"dual-loop, guardian, chains","product-aura.e1d4ca4876":"ratatui, tabs, diff, search","product-aura.a4e5cbfb21":"~22 MB static","product-aura.7e491a565f":".rs files in src/, single static binary","product-aura.a4001d2046":"src/ tree, ~330 KLoC Rust","product-aura.0ab35bf760":"CODE FOOTPRINT","product-aura.c9ab31eaf2":"TYPED BUS","product-aura.75d879c9f3":"ASYNC TOKIO","product-aura.fd2aa556a6":"The TUI sits on top, the coordinator dispatches to the LLM orchestrator (dual-loop + Guardian + judge), the agent registry (chains / parallel / teams / background), and the state store (sessions / memory / config). Tools, security and audit ride underneath.","product-aura.486d7f9392":"One typed bus between them.","product-aura.cdc5413568":"A coordinator and four async layers.","product-aura.f2e8ceabcb":"Module map","product-aura.09ecc8d4b5":"One static binary","product-aura.e098a03fc9":"~330 KLoC Rust, 433 .rs files in src/","product-aura.2e2c3c7006":"VERIFY ONE-SHOT","product-aura.e20ef49323":"SIEM EXPORT","product-aura.b544bacb65":"BLAKE3 CHAIN","product-aura.db35ca65d0":"JSONL","product-aura.1851655bfa":"Append-only JSONL where each line carries BLAKE3 hash of the previous. Tamper any entry, every following hash breaks. Verifiable in one call.","product-aura.a303f3eac5":"AUDIT, src/audit","product-aura.5de0f116f0":"BM25 RANK","product-aura.798e0a809a":"SQLITE","product-aura.26b777ff9f":"SQLite + FTS5 cross-session memory. BM25-ranked retrieval, token-budget injection, automatic pruning of stale entries.","product-aura.053cbfe7c4":"MEMORY, src/memory","product-aura.f687af47e9":"CACHE","product-aura.21593b807a":"MCP","product-aura.3d3b56ea6f":"CODEBASE","product-aura.32c7e82051":"WEB FETCH","product-aura.c500510607":"SHELL, GIT","product-aura.d129ad76e1":"FILE I/O","product-aura.18f920f56d":"25+ builtins plus MCP and external. Each tool runs the same 15-stage pipeline: ACL → cache → output filter → PII → audit.","product-aura.1b92330667":"TOOLS, src/tools","product-aura.751ecfe9a7":"COMPACTOR","product-aura.0b61e2eaab":"GUARDIAN","product-aura.2ae3dbc9c1":"INNER LOOP","product-aura.025d0fadd0":"OUTER LOOP","product-aura.84a8354234":"Dual-loop engine: outer plans, inner executes with mid-turn steering, Guardian watchdog catches doom loops + stalls + budget overruns.","product-aura.6149b09cd3":"AGENT, src/agents","product-aura.4848920651":"SESSION STORE","product-aura.cb770ac073":"KEY ROUTING","product-aura.55ef40ecf6":"TOKIO ASYNC","product-aura.5d47dcc620":"Async dispatch to LLM orchestrator, event handler, renderer, state. Focus, keyboard routing, session persistence on the typed bus.","product-aura.295db154cb":"COORDINATOR, src/app","product-aura.37fa762f04":"HOT-RELOAD THEME","product-aura.da68c1cc32":"FILE TREE","product-aura.69051ae4af":"DIFF VIEWER","product-aura.1f93d1a4cb":"TABS","product-aura.a9e4e314c9":"ratatui terminal: tabs, chat, file tree, diff viewer, settings, stats. Syntax via tree-sitter, with an undo history.","product-aura.8191725d96":"UI, src/ui","product-aura.6036d8b848":"CORE MODULES, src/ tree","product-aura.67d35c68c7":"Core modules","product-aura.5315129cfe":"macOS, Linux, Windows","product-aura.8d285d2cd6":"cargo build, release profile","product-aura.483142fcff":"DAG-based with builtins","product-aura.825ce9e97d":"Workflows","product-aura.0ac4c87978":"Chains, parallel, teams, background","product-aura.6926cb0e99":"Orchestration","product-aura.6410a8af21":"AST bash, PII filter, sandbox","product-aura.f25ce1b8a3":"Security","product-aura.778b6b7a4b":"Append-only JSONL, BLAKE3 chain","product-aura.1348246476":"SQLite + FTS5 cross-session","product-aura.89c8a2851d":"Memory","product-aura.5dd30bb0b3":"Complexity-based selection","product-aura.7d15dd1bec":"Routing","product-aura.f2a6ce9a5b":"Anthropic, Mistral, OpenAI-compatible, +MCP","product-aura.bc68575f55":"25+ builtin, MCP, external","product-aura.4fa8cc860c":"Tools","product-aura.49c211b015":"Dual-loop + Guardian watchdog","product-aura.5ce2e6f402":"Agent","product-aura.2c9686b176":"ratatui + crossterm","product-aura.7b0d813242":"~22 MB static, no runtime deps","product-aura.66639f7d45":"Binary","product-aura.f391126b51":"Rust 2021, 433 .rs files in src/","product-aura.89b86ab0e6":"Language","product-aura.0974d264ed":"~330 KLoC Rust, single binary","product-aura.a8aed5830a":"TECH SPECS","product-aura.4856e069c1":"tech specs","product-aura.af0854de67":"Aura","product-aura.5442247802":"TYPED EVENT BUS","product-aura.fd718c7b0e":"The Terminal UI sits on top, rendering tabs, chat, file tree, diff viewer and overlays. The coordinator dispatches to the LLM orchestrator (dual-loop agent + Guardian + goal judge + token tracker + three-tier compactor), the typed event bus, the state store (config / sessions / memory), and the agent registry (chains / parallel / teams / background). The backend layer talks to Anthropic, OpenAI, Mistral and MCP servers through a complexity router. The tool system exposes 25+ builtins plus MCP and external integrations. The security layer enforces sandboxing, PII detection and prompt-injection filtering. Everything is wrapped by an audit trail that writes append-only JSONL chained with BLAKE3.","product-aura.efa14c75d2":"Aura is organised around a modular app coordinator that manages four subsystems: the TUI renderer (ratatui + crossterm), the LLM orchestrator (dual-loop agent with Guardian), the event bus (typed pub/sub), and the state store (configuration, sessions, memory). All communication is asynchronous via tokio.","product-aura.80856d3ea4":"One async binary.","product-aura.81763daf1a":"agent, event bus.","product-aura.240ba2a1f2":"TUI, coordinator,","product-aura.38750ed448":"Stack at a glance","product-aura.8c3f257dd9":"AST bash analysis, PII filter, sandbox","product-aura.a32b396118":"Append-only JSONL + BLAKE3 chain","product-aura.5231380f02":"Complexity-based model selection","product-aura.b4dad06170":"Tech specs","product-aura.33c0fde53c":"Aura is a ~330 KLoC Rust autonomous development agent featuring a ratatui TUI, dual-loop reasoning with Guardian watchdog, 25+ built-in tools with circuit breakers, multi-backend LLM orchestration with smart routing, SQLite semantic memory, BLAKE3-chained audit trails, MCP client, multi-agent chains/parallel/teams, and DAG-based workflows. Single ~22 MB binary.","product-aura.d14234f88a":"audit and 25+ tools.","product-aura.70a3279c56":"agent with tamper-evident","product-aura.794cdffd67":"Rust-native autonomous","product-aura.b4b5a3e367":"Product, Aura","product-aura.71074ab646":"Read docs","product-aura.8ad98610e0":"Talk to sales","product-aura.728425893e":"Request enterprise access","product-aura.1e9352dee7":"Start with a pilot team, measure productivity gains, and scale across your engineering organisation. Enterprise support, custom training, and dedicated engineering available.","product-aura.0a637bd1e6":"Deploy Aura in your organisation.","product-aura.1ae137a178":"Aura, Business","product-aura.f564379e6c":"EXPORTABLE EVIDENCE","product-aura.9146b5fc82":"PII REDACTED","product-aura.7d3f5297bf":"LOCAL BY DEFAULT","product-aura.7801fd70a3":"Aura runs on infrastructure you control, strips personal data before anything leaves, gates every tool behind a permission, and records every action in a tamper-evident trail. None of this is a certification claim. These are real controls that give your GDPR, EU AI Act, NIS2 and DORA reviews concrete, exportable evidence instead of promises. Defaults are conservative; you turn the knobs up, never quietly down.","product-aura.ac4df5b5dd":"already on file.","product-aura.1e6b660671":"The evidence your reviewers ask for,","product-aura.8327e8eefa":"Security and compliance","product-aura.eb1c3b1c50":"COMPLIANCE GAPS","product-aura.af64b49db2":"KNOWLEDGE LOSS","product-aura.bcc7c7c9ad":"ROUTINE WORK","product-aura.da2ae76ed2":"Teams spend hours on work that does not need human creativity: finding bugs, writing boilerplate, updating dependencies, refactoring legacy code, onboarding people. Existing AI tools help but add their own problems, code shipped to the cloud, silent changes, no record. They rarely work across files or coordinate between people. Aura folds the assistant, the search, the memory, the security checks and the audit log into one program you already run.","product-aura.f34c953b9d":"So is the cost of seven tools to handle it.","product-aura.599c3ef689":"The routine work is real.","product-aura.b039d4427c":"One platform, not seven tools","product-aura.08ad24b8c4":"Run with local AI models (Ollama, llama.cpp) for fully offline operation. No network connection required. All features work except cloud LLM backends.","product-aura.87a3373a5c":"Offline operation","product-aura.ad3158ba54":"Official Docker image with multi-stage build. Run in Kubernetes, Docker Compose, or any container platform. Mount your codebase as volume for persistent access.","product-aura.3f5f1bb3ef":"Docker deployment","product-aura.8f747c15b6":"CONTAINER","product-aura.3e45ff8aff":"Single binary, no install. Download, set your API key, and run. Works on macOS, Linux, and Windows. Configuration stored in ~/.dweve/ with project-level overrides.","product-aura.fe061a16e1":"Developer laptop","product-aura.9be34046ca":"LOCAL","product-aura.6a0d624f58":"Deployment scenarios","product-aura.811b86df64":"Aura deploys as a single binary with no runtime dependencies. Run it on a developer laptop, in a container, on a server, or in an air-gapped environment. Configuration is via TOML files with hot-reload support.","product-aura.944785c204":"your way.","product-aura.bcc9984a00":"Run it","product-aura.327a55f82d":"Deployment","product-aura.feba788cae":"Run Aura in CI pipelines for automated code review, test generation, and quality checks. JSON output integrates with Jenkins, GitHub Actions, GitLab CI, and custom dashboards.","product-aura.82c7395bfd":"Pipeline integration","product-aura.3b1956a5ea":"Connect to external MCP servers via stdio JSON-RPC 2.0. External tools appear alongside Aura's builtins with the same permission and audit controls.","product-aura.48a9aebc9d":"Native support for Anthropic Claude, Mistral, OpenAI-compatible providers (Groq, Together, DeepSeek and more), and Anthropic-compatible APIs. Smart routing selects the cheapest capable model for each task. Fallback chains ensure continuity if a provider is down.","product-aura.7b9a1b058d":"Multi-backend support","product-aura.4b1e9501b9":"Connectors","product-aura.7863ecb1d5":"Aura integrates with the tools your team already uses. It connects to multiple LLM providers, speaks the Model Context Protocol for external tools, and exports audit data in standard formats. No rip-and-replace required.","product-aura.da3daf4cf9":"existing tools.","product-aura.15383d1ad2":"Works with your","product-aura.899e5920ef":"Integration","product-aura.4043a57382":"Teams of agents share task boards, exchange messages, and enforce quality gates before passing work downstream. Terminal multiplexer detection (tmux, zellij, kitty, wezterm) enables multi-session workflows.","product-aura.6edd132ab2":"Coordinated agents","product-aura.3f939fcae3":"Run multiple agents simultaneously on different parts of a problem. Results are aggregated using configurable strategies: unanimous, majority, first-success, or custom merge functions.","product-aura.14a1d11dd8":"Define multi-step agent chains where the output of one step becomes the input of the next. Variable substitution passes context between steps. Built-in chains for debugging, feature implementation, optimisation, and code review.","product-aura.c109cc1661":"Scaling stages","product-aura.6ad18ab3f2":"Aura scales from a single developer asking questions to enterprise teams running coordinated agent workflows. Multi-agent orchestration includes sequential chains, parallel execution with result aggregation, team coordination with shared state, and background task management.","product-aura.2b5c222fc4":"A coordinated team does more.","product-aura.43ebe70d04":"One agent is useful.","product-aura.d581b51a95":"Team scaling","product-aura.93414718cd":"Every event is appended to a JSONL file with BLAKE3 hash chaining. Deleting or modifying an entry breaks the chain, making tampering detectable. Export to SIEM or compliance platforms via standard formats.","product-aura.1309b0b935":"Immutable evidence","product-aura.c0e8c9dbb3":"Each tool tracks recent success and failure outcomes in a sliding window. A tool that fails repeatedly is automatically blocked for a cooldown period, preventing cascade failures and retry storms.","product-aura.9ca1dcbd2e":"Before executing any shell command, Aura parses it into an AST and checks for dangerous patterns: rm -rf, pipe to shell, network exfiltration, and privilege escalation. Blocked commands are reported with explanations.","product-aura.53a2076b59":"AST-based command review","product-aura.d70ea723d9":"Multi-stage prompt injection detector analyses user input, tool output, and LLM responses for adversarial patterns. Suspicious content is flagged and quarantined before processing.","product-aura.cfcecd21b4":"Attack detection","product-aura.75e2795dfe":"Built-in PII detector identifies emails, phone numbers, credit cards, API keys, and national identifiers in tool output and conversation history. Detected values are redacted before transmission to LLM providers.","product-aura.4b6fe251c0":"Automatic detection and redaction","product-aura.f8e2f05ba4":"Each tool can be set to Always (run without asking), Ask (prompt for approval), or Never (disabled). File access is constrained by glob patterns and path containment rules.","product-aura.6034ca74ef":"Permission levels per tool","product-aura.65559d6344":"Security layers","product-aura.ea0204c606":"AST BASH ANALYSIS","product-aura.89b6e2a784":"DEFENCE IN DEPTH","product-aura.b8a61e3dc9":"Each layer is configurable per project, per session, and per environment, bash AST analysis on, PII redaction always, prompt-injection scoring at the threshold your security team chooses. The audit trail is BLAKE3-chained and exports cleanly to SIEM and binders for GDPR, EU AI Act, NIS2 and DORA reviews. Defaults are conservative; turn knobs up, never down.","product-aura.ca9a03ea6f":"Aura's security model operates at three independent layers: a tool sandbox that gates every dangerous operation behind permission and AST analysis, a content filter that stops PII leakage and prompt-injection attacks before they reach the LLM, and a tamper-evident audit trail that produces the evidence your compliance team will actually be asked for.","product-aura.30887811d2":"not bolted on.","product-aura.b929a573fe":"Security built in,","product-aura.a5be1735f4":"Defaults conservative, tune up","product-aura.fab0008068":"Every layer configurable per project","product-aura.c2e37f2378":"SANITISE","product-aura.c300041703":"INJECTION GATE","product-aura.5a5eaec8f1":"PII REDACT","product-aura.5163f6a3af":"FILE ACL","product-aura.a2c94a5595":"BASH AST","product-aura.3200b77b4e":"Enterprise guardrails: AST bash analysis, file ACLs, PII redaction, prompt-injection detection.","product-aura.0a7b77e1bf":"SECURITY","product-aura.060ef6c824":"HOT-RELOAD CTX","product-aura.1040c32905":"FTS5, BM25","product-aura.bb7554bd7f":"Aura remembers your style, conventions and decisions across sessions.","product-aura.7d1b977f6a":"SEMANTIC MEMORY","product-aura.0152fb697e":"PER-TASK PICK","product-aura.b02e68872a":"FALLBACK CHAIN","product-aura.7ae67df110":"4 TIERS","product-aura.7c705b2d70":"Classifies task complexity and picks the cheapest capable model from your registry, so easy work does not pay for a frontier model.","product-aura.9ca40782ab":"SMART ROUTING","product-aura.18afa7b49c":"WORK LEDGER","product-aura.0ea215ea0d":"BACKGROUND","product-aura.9fc6fb7e03":"TEAMS","product-aura.018d2cd1a5":"PARALLEL","product-aura.16623c5d4a":"CHAINS","product-aura.7ed4d1803d":"Coordinate teams of agents, sequential chains, parallel runs, shared task boards, background work.","product-aura.272b08cdee":"INCIDENT REPLAY","product-aura.41f2628dbb":"JSONL, SIEM-READY","product-aura.5bac9e13cc":"Every tool call, routing decision and file change recorded in an append-only JSONL chain.","product-aura.603517284c":"AUDIT TRAIL","product-aura.a0705f6f7e":"CODE SEARCH","product-aura.4801cfdded":"A complete toolkit, every call permission-gated, cached and circuit-broken.","product-aura.1ded0cc222":"25+ TOOLS","product-aura.3dcd2721b1":"WHAT AURA DELIVERS","product-aura.caf7d69353":"Core capabilities","product-aura.9ea21d197d":"Talk to Dweve","product-aura.afaf0e09a4":"Pilot in days","product-aura.a04a363c18":"Dweve, in Europe","product-aura.eae192773b":"Made by","product-aura.29182147cd":"ratatui terminal interface","product-aura.1e94d20be1":"BLAKE3 hash chaining","product-aura.12943ca9a9":"SQLite + FTS5","product-aura.e38ba37d86":"Anthropic, Mistral, OpenAI-compatible, MCP","product-aura.b3776d63ad":"Backends","product-aura.15960660f9":"25+ built-in","product-aura.6078c11295":"~22 MB single file","product-aura.433ae428b4":"Binary size","product-aura.e2ae20d9ae":"Rust","product-aura.bca0a95dec":"Commercial Dweve product","product-aura.ca9dff97b5":"PRODUCT SHEET","product-aura.9fd5ed2efe":"TAMPER-EVIDENT AUDIT","product-aura.4cbb7a4847":"Aura is not a chatbot that suggests snippets. It is an autonomous agent that understands your entire codebase, plans multi-step changes, executes them with your approval, and documents every decision in an immutable audit trail. It scales from individual developers to enterprise teams with multi-agent orchestration.","product-aura.f9abab6391":"and leaves a trail.","product-aura.4c68b75db3":"Writes code, explains itself,","product-aura.6269f248c1":"What Aura delivers","product-aura.822f1412da":"SQLite with FTS5","product-aura.2f09460ea1":"Product sheet","product-aura.d4a74b503a":"Read the docs","product-aura.dc7b0c63c7":"Aura is an AI development agent that works in your terminal, understands your codebase, and writes code with full transparency. Every change is explained, every tool call is logged, and every session leaves an audit trail. 25+ built-in tools, multi-agent orchestration, and security guardrails that keep you in control. Built in Rust, runs anywhere.","product-aura.0e4225c6f5":"and prove it.","product-aura.115220cdf6":"Agents that write code","product-aura.3305cf1bdb":"Request Aura access","product-aura.c5b5fbdd5d":"Download the single binary, run it in your project directory, and start asking questions. No account required for local use.","product-aura.19d7dbe168":"Explore Aura.","product-aura.ad286ecce1":"All in one ~22 MB binary","product-aura.0d5716f14a":"Configurable per project","product-aura.bb0335fd13":"BACKGROUND TASKS","product-aura.56fdbd7a38":"GOAL MODE","product-aura.44a265d33e":"type to redirect","product-aura.d659313613":"INTERRUPT","product-aura.8b75f9eaed":"STREAM","product-aura.6591983e6f":"Steer mid-response. Aura listens while it works.","product-aura.50978fadde":"CONTROL","product-aura.5c762e0265":"AUDIT","product-aura.8a48f4ff3b":"TESTS","product-aura.2d109b00a5":"CLIPPY","product-aura.9c8b212b27":"FMT","product-aura.35d806fa4f":"Run the whole pipeline after a change. Fail fast, fix in place.","product-aura.fb7c2e80ac":"QUALITY","product-aura.3e750c32c0":"CLI ADVISORY","product-aura.6daeadd83f":"Ollama, llama.cpp","product-aura.ac76fc78cd":"MISTRAL","product-aura.d9fadd0948":"OPENAI","product-aura.f2b2a1c3ea":"ANTHROPIC","product-aura.0c18a26fc8":"Bring your own AI. Smart routing picks cheap for easy, capable for hard.","product-aura.441baeb74e":"MODELS","product-aura.2d5d10cfc5":"CLAUDE.md","product-aura.42cb5e9235":"FTS5 RECALL","product-aura.2897a7efa1":"CONVERSATION","product-aura.074aff4bd4":"PROJECT PREFS","product-aura.1df68802b4":"Aura remembers your project. SQLite + FTS5 search across days.","product-aura.f4b1c471ce":"MEMORY","product-aura.6ffd3023bb":"attach by name","product-aura.3298a763d2":"on relaunch","product-aura.a26a6ebdc9":"RESUME","product-aura.dbc8742034":"CLOSE","product-aura.7455f92b6b":"Alt+1 to 9","product-aura.bb0d79b578":"JUMP","product-aura.66aabd91fc":"NEW","product-aura.e2e4f6552a":"Tabs across the top. Switch projects without losing context.","product-aura.721147ddfd":"SESSIONS","product-aura.02ce66c3b2":"OPTIMIZE","product-aura.ed6912ad70":"REVIEW","product-aura.c4d24d25ec":"REFACTOR","product-aura.dcb15895c6":"FEATURE","product-aura.3f67e8f4ee":"DEBUG","product-aura.0f1b1323e0":"One keyword runs a multi-step DAG. Five shipped, more on disk.","product-aura.dbb15a1dcb":"WORKFLOWS","product-aura.4b36e40148":"WHAT ELSE YOU GET","product-aura.b502069254":"Aura, Consumer","product-aura.440756dcc0":"`@file` to attach","product-aura.02b9085537":"Tab to autocomplete","product-aura.2ebb98220b":"Show every command, agent and tool","product-aura.9fec8a7ebc":"Open any file in the in-TUI viewer","product-aura.8777274eb0":"Switch agents or compose a chain","product-aura.2dcc056663":"Search the chat or your codebase","product-aura.98c4857168":"Compare any two files, or your last patch","product-aura.f79c2505d4":"Run fmt, clippy, tests, doc-tests, audit","product-aura.4b20d35a99":"Declare a target and let Aura work until it’s met","product-aura.3625bd40c7":"A few of the regulars","product-aura.e7bb82f37c":"SLASH COMMANDS","product-aura.6dbdc17175":"5 BUILT-IN WORKFLOWS","product-aura.ac4fc2bda6":"Aura is built like a tool, not a chat. Multi-session tabs, slash commands, ready-made workflows, cross-session memory, smart routing, and a quality pipeline that runs after every change, all keyboard-first.","product-aura.1cc703b104":"not a prompt box.","product-aura.cf84ef16aa":"A workspace,","product-aura.731a0df3b6":"More than ask-and-answer","product-aura.ce66ee1530":"// returns 401 instead of panicking","product-aura.96bf47998c":"let user = ctx.user().ok_or(Error::Unauthenticated)?;","product-aura.323a4d9326":"let user = ctx.user();","product-aura.ed2dfb22aa":"Aura shows you exactly what it plans to do. You can approve, reject, or modify every suggestion. Your code only changes when you say so.","product-aura.266a9a0b8f":"You decide","product-aura.af319eaa7d":"YOU","product-aura.6851a9ffb4":"plan, add guard + test case","product-aura.1b1a240f5c":"cause, missing guard before deref","product-aura.0388621d7b":"trace, null path on line 42","product-aura.51578d7490":"read, session.rs, auth.rs","product-aura.f1c30c13e0":"Aura reads relevant files, analyses your code, and plans a response. It may ask clarifying questions if your request is ambiguous.","product-aura.dbcaabe65c":"Aura thinks","product-aura.b51abe47a6":"context, open file","product-aura.2fa0e98fd8":"~/project, session.rs:42","product-aura.e78cf60058":"Why does this throw on null input?","product-aura.6f68edd785":"Type your question or request in plain English. Aura understands context from your current file, project structure, and conversation history.","product-aura.7ed149da71":"You ask","product-aura.b4b5949da9":"no rejections","product-aura.77b244eff0":"3 approvals","product-aura.ef382660cb":"rename, sessionUser → currentUser","product-aura.c11c655ef7":"tests, auth/session.test.ts","product-aura.e80e4b29f7":"patch, src/auth/session.rs","product-aura.48c2a13dc6":"This session","product-aura.be474987ec":"APPROVAL LEDGER","product-aura.704fcb2d8c":"Cloud calls by default","product-aura.2a013662e0":"Binary, no install","product-aura.0496bf36fe":"Every change reviewed before it lands.","product-aura.5e2fd48681":"Decisions gated by you","product-aura.0bde035688":"UNDO ANY TIME","product-aura.9f8f719231":"YOU APPROVE","product-aura.3a5d97244a":"PLAIN ENGLISH","product-aura.0b7530f324":"Aura works like a pair programmer who explains their thinking, proposes changes, and waits for you to say yes or no before touching anything.","product-aura.ea021fa488":"No silent rewrites.","product-aura.6810cf06d0":"You stay in control at every step.","product-aura.1dd6a17cb4":"How it works","product-aura.0bfdc9ccf8":"STAYS ON YOUR COMPUTER","product-aura.0664419261":"IT WAITS FOR YOUR YES","product-aura.4761efdb1e":"PLAIN WORDS","product-aura.cb9dfffb64":"You do not need special terms or training. Tell Aura what you want in everyday language and it does the work, then waits for you to say yes. Here are the kinds of things people ask it every day.","product-aura.1fd139f362":"like talking to a helpful person.","product-aura.f26ea16f48":"Ask in plain words,","product-aura.d4062ec2bc":"What you can ask","product-aura.9272b69bb3":"Aura pulls examples from your own project and walks you through the pattern, grounded in code you already trust.","product-aura.33ef21e039":"Explain async/await, using my code.","product-aura.befdbacfe3":"Aura searches your codebase, surfaces the relevant files and lines, and points you at the call sites that matter.","product-aura.71f0b5f74e":"Where is authentication handled?","product-aura.7401034083":"Aura proposes a structure, shows a diff per file, and renames callers. Nothing moves until you approve.","product-aura.3159b111eb":"Split this 600-line file by responsibility.","product-aura.07f636c3bc":"Aura reads the surrounding code, traces data flow, and explains it in plain language with the dependencies it touched.","product-aura.3a143fa77a":"What does this function actually do?","product-aura.e9432ac9c5":"Aura drafts cases covering normal inputs, edges, and error paths, and shows the new test file before saving.","product-aura.033518fd05":"Add tests for parseConfig().","product-aura.d1fb22dbb7":"Aura traces the error through your code, identifies the cause, and proposes the patch. You review the diff before it touches anything.","product-aura.cc9bc9cc4e":"Why does this throw on null?","product-aura.3cf9da602b":"What you can ask Aura to do","product-aura.bd85c7eaf1":"No cloud required","product-aura.f2df0fefc1":"Single ~22 MB binary","product-aura.d7a9f1b2a8":"Any code editor","product-aura.a129a012ae":"Works with","product-aura.c52ba98d06":"One binary, no install","product-aura.cdd7bb2816":"Setup","product-aura.e0cb77fa3f":"Code stays on your machine","product-aura.cf01481f62":"Privacy","product-aura.79cedeb30a":"Free tier available","product-aura.64ae43e8fe":"Cost","product-aura.a7b7b9250a":"Coding assistant in your terminal","product-aura.f8c94a3b4b":"What it is","product-aura.4e6a22430e":"AT A GLANCE","product-aura.74d46bc12f":"YOU APPROVE EVERY CHANGE","product-aura.611e2b61f2":"LOCAL FIRST","product-aura.713f474351":"Unlike cloud-based coding assistants that send your code to remote servers, Aura runs entirely on your machine. Your source code never leaves your computer unless you explicitly choose to use a cloud AI provider.","product-aura.9a123f435d":"Aura is a program that lives in your terminal and helps you write code. You type questions or commands in plain English. Aura reads your code, thinks about what you asked, and suggests changes. You see every suggestion before it is applied. Nothing happens without your approval.","product-aura.af6e1e4edb":"Plain English in. Code changes out.","product-aura.a08b313386":"inside your terminal.","product-aura.3afeab35fd":"A smart helper","product-aura.f39ee14e97":"What Aura is","product-aura.4144d9ee43":"Code stays local","product-aura.fca77b7e3a":"At a glance","product-aura.20f75164f4":"Try Aura","product-aura.99df04244d":"Aura sits in your terminal and helps you write better code faster. Ask it to fix a bug, explain a function, or write a test. It shows you exactly what it plans to do, asks before making changes, and keeps a record of everything. Your code stays on your machine. No cloud required.","product-aura.65546903ed":"for writing code.","product-aura.497fe43859":"An AI assistant","product-aura.fe0a091fdb":"Products","product-aura.5ba3e4e235":"Dweve Aura, closed-loop development","product-aura.2a149d1acb":"A patch is not finished when it is written.","product-aura.cd9b947664":"It is finished when the goal is met.","product-aura.97293632d4":"Aura is Dweve's AI coding agent runtime: a closed loop around the models your team chooses. It plans, acts on the real repository under human steering, judges the result against explicit criteria, and keeps the operational record. The model can change; the engineering loop remains Aura.","product-aura.cbe48730b2":"See the loop","product-aura.e79474558d":"The engineering record","product-aura.5937cb74fc":"CLOSED LOOP","product-aura.4180aa3c81":"One runtime","product-aura.00d8323696":"native Rust binary","product-aura.1b56867e20":"Every tool","product-aura.95b3694a26":"one execution pipeline","product-aura.e8d05b931c":"Definition of done","product-aura.2cc2538e11":"executable criteria","product-aura.4264c9bb91":"BLAKE3 hash-chained","product-aura.f9375afaa7":"Human authority","product-aura.259451afde":"live, not after the fact","product-aura.db1e97dbb9":"What is your team doing after the model says it is done?","product-aura.16a8d244f3":"Open-loop development","product-aura.8a00359053":"Prompt. Patch.","product-aura.b3467ffbf4":"Hope.","product-aura.dbb10b1660":"Most coding agents stop at model output. The developer then runs the tests, finds the drift, pastes failures back, explains project rules again, repairs collisions, and reconstructs what happened for review. The work appears autonomous because the model calls tools. The human is still the control loop.","product-aura.366ae2d29d":"The patch may compile or not. It may fix the symptom and miss the cause. It may change another path the model never checked. The missing product is not another model. It is the loop around it.","product-aura.79166451f9":"PROMPT IN, PATCH OUT","product-aura.6a1b496a55":"HUMAN CLOSES IT","product-aura.e0e46a7730":"STATE LEFT BEHIND","product-aura.7f400bad66":"After the patch","product-aura.0f8073b1b3":"the manual work column","product-aura.95227c2b58":"Run the tests","product-aura.b69e883574":"The developer, not the agent, checks the result.","product-aura.2bfeaae63a":"Paste the failure back","product-aura.574415d761":"The error returns to the chat by hand.","product-aura.73f56c8939":"Explain the convention","product-aura.3c8559d979":"The project rule is repeated again.","product-aura.71dfa48eea":"Undo the wrong file","product-aura.7640eefe09":"A side effect is unwound manually.","product-aura.0b08b964a9":"the model produced code","product-aura.aa40ab4f94":"the team produced the loop","product-aura.bf91c1ad87":"The missing product is not another model. It is the loop around it.","product-aura.3e820e3f22":"The human loop","product-aura.d10bfe5267":"The model wrote the code","product-aura.80c2e96024":"your team did the engineering.","product-aura.003afb9cd7":"Generation speed can move work into review rather than remove it. Developers carry context between the assistant, shell, test runner, Git, security checks, issue tracker, and reviewer. Seven surfaces sit between the request and the merged change, and the only thing carrying state across them is one person's attention. Aura makes that state explicit and reusable instead of leaving it in one person as attention.","product-aura.600edb4903":"Which files were read, which assumptions were made, which command output mattered, which change broke the tests, which rule was ignored, whether the task is actually complete. Aura makes that state part of the runtime.","product-aura.b49fe32222":"STATE MADE EXPLICIT","product-aura.ed65b3964d":"CARRIED BY THE RUNTIME","product-aura.a856de380d":"NOT ONE ATTENTION","product-aura.7a575bec9e":"Seven surfaces, one carrier","product-aura.3666e34305":"the developer moves the cards","product-aura.27a9612b32":"assistant","product-aura.ec122f54cf":"shell","product-aura.394046ef6e":"test runner","product-aura.5819778898":"Git","product-aura.8eec7bc461":"security","product-aura.8557b33974":"issue tracker","product-aura.0b7cec9c67":"reviewer","product-aura.387784defb":"cards carried by hand","product-aura.0806f014fd":"one loop state in Aura","product-aura.6662b294ab":"What changes when the objective, feedback, and definition of done share one runtime?","product-aura.eef6a003d1":"Closed-loop development","product-aura.f5c1bdf442":"Goal in.","product-aura.47068dd0a0":"verified outcome out.","product-aura.96f2c260df":"A task enters with an objective and success criteria. Aura retrieves the project state, creates a plan, executes one bounded action, observes what actually happened, accepts policy and human feedback, checks the result, and either finishes, stops honestly, or replans. When the first test fails, verification returns to planning rather than to a final answer.","product-aura.1c208b651a":"The system does not assume the first plan remains correct after it touches the code. Tool output changes the state. Tests reveal new information. Aura treats each of those events as feedback into the next decision.","product-aura.115d07f624":"PLAN, ACT, OBSERVE","product-aura.f00cd5a059":"JUDGE, THEN REPLAN","product-aura.774e110d46":"FINISH FOR A REASON","product-aura.0a8c481e25":"The loop nodes","product-aura.f35a216c4d":"the patch is one state, not the end","product-aura.9fe00acebc":"Goal","product-aura.ae2f98a099":"Plan","product-aura.138a104b73":"Act","product-aura.c99a2bcf3e":"Observe","product-aura.02f4a3c6aa":"Steer","product-aura.dda6ac27b9":"Verify","product-aura.90f3c4a018":"Judge","product-aura.3813cb6205":"Finish or replan","product-aura.c3c02a8519":"the first test fails","product-aura.78c46c95eb":"Verify returns to Plan","product-aura.5646cee076":"The loop only matters if the developer remains able to steer it.","product-aura.5cc4f50278":"You have seen this pull request","product-aura.c16c006f26":"The agent changed seven files for a three-line bug.","product-aura.becb7aef71":"Nobody knows which command failed first, and the developer pasted the test output back twice.","product-aura.058ce92ca7":"Security found the risky shell call after the session ended, and the review explains the patch, not how it was produced.","product-aura.19481d1540":"Around one open-loop handoff","product-aura.932d6b786a":"Seven files for three lines","product-aura.b5486134e5":"The first failure, unknown","product-aura.138f0e0987":"The test output, pasted twice","product-aura.71d4cae6cf":"The risky shell call, found late","product-aura.655dbbe20a":"The model produced code. Your team closed the loop.","product-aura.33856ec10f":"Review should not begin","product-aura.3b09a5ef3a":"after autonomy ends.","product-aura.8554b64c6c":"Aura supports per-tool permissions, project and session policy, mid-turn steering, cooperative abort, file checkpoints, undo, and isolated worktrees. A developer can correct the run while the relevant state is still active, rather than reviewing a finished mistake afterwards. Approve, redirect, pause, abort and undo stay available for as long as the run is live. Authority over each action stays with the developer; completion stays with the stated criteria.","product-aura.61c488a330":"The developer can see the plan, inspect proposed changes, require approval for selected tools, redirect between tool calls, and stop a run cooperatively. Human involvement is one feedback source inside a controlled system, not a failure of autonomy.","product-aura.08bc11d639":"STEER MID-TURN","product-aura.cf357def49":"APPROVE OR ABORT","product-aura.f937c8efac":"UNDO IN PLACE","product-aura.fb6c184300":"The control rail","product-aura.e45b6294cf":"live while the work runs","product-aura.7b2c7f146a":"Approve","product-aura.58cfcdca5e":"Redirect","product-aura.781961bc81":"Pause","product-aura.6f3abbe484":"Abort","product-aura.39fc721248":"Undo","product-aura.aa231e503a":"authority controls the action","product-aura.e713c44725":"criteria control completion","product-aura.fe74832021":"Authority controls the action. Success criteria control completion.","product-aura.48eec06633":"Goal-driven work","product-aura.f34b7ce5cf":"The answer is not done.","product-aura.9444d1f359":"the outcome is.","product-aura.e529258355":"Goals can carry deterministic criteria such as test pass, file existence, substring, and regular-expression conditions. The fast judge evaluates those checks first. An optional model judge handles the criteria that cannot be reduced to a simple check. A goal with four criteria closes only when all four are green; three green and one failing sends the run back to planning. The quality criterion clears through the project's own pipeline, so the bar is the one the team already enforces.","product-aura.0d9b7a8415":"A run closes for a stated reason rather than because the assistant wrote a final paragraph. The model is not asked to grade its own answer when the repository can answer directly.","product-aura.438be7b6d5":"CRITERIA ATTACHED","product-aura.dc40d9aa34":"DETERMINISTIC FIRST","product-aura.1080fe5bf4":"JUDGE ONLY THE REST","product-aura.87f73cc3d3":"A goal, four criteria","product-aura.be3a0f01da":"three pass, one replans","product-aura.53b54503c0":"Test passes","product-aura.a651511364":"checked deterministically","product-aura.e4abf36a5e":"File exists","product-aura.f6874487c4":"Output matches","product-aura.35277b2570":"substring or regular expression","product-aura.d0bdf5afa5":"Quality clears","product-aura.fe504ae4d1":"pipeline under project policy","product-aura.5ae84b0a5b":"goal satisfied","product-aura.7d1d16d59d":"each criterion green","product-aura.a84d26fb99":"Quality is not a report after the task. It is feedback inside it.","product-aura.b09eb31be6":"Fail fast.","product-aura.e3ffa8a987":"Fix in place.","product-aura.4ff793c5a2":"Aura can run format, lint, compile, test, documentation-test, and security-audit stages under project policy. A failure becomes observed state for the next plan. Warnings can remain advisory or become blocking gates. The repository, not the model as confidence, provides the feedback.","product-aura.0be0d774db":"The quality stages are not a report generated after the agent declares success. The agent can inspect a failure, repair the cause, and rerun the relevant gate. Definition of done becomes executable.","product-aura.f2faf8dd3b":"SIX STAGES","product-aura.dac9689fe4":"FAILURE IS STATE","product-aura.14856aec30":"GATES BY POLICY","product-aura.122e590b1f":"The quality stages","product-aura.ebacca556d":"a failure returns to the loop","product-aura.785987648f":"format","product-aura.b504838caf":"lint","product-aura.36d0981b33":"compile","product-aura.a94a8fe5cc":"test","product-aura.cea2eb3659":"doc tests","product-aura.7876153ada":"audit","product-aura.0abdcffb48":"tests fail","product-aura.e64f3799f0":"repair, then pass","product-aura.a22afb2fa5":"Before any tool acts, it passes through the engineering boundary.","product-aura.508d84493e":"Tool runtime","product-aura.d5c46f3adc":"One agent can call many tools.","product-aura.658b84dab7":"all under the same rules.","product-aura.3d7722e0fe":"Built-in tools and registered external tools enter a common pipeline for scope, permission, shell analysis, file policy, checkpoints, caching, timeout, output filtering, sanitisation, PII handling, audit, and failure isolation. Capability can expand without creating a second trust model.","product-aura.f31f06cac0":"A new tool does not receive a new trust model merely because it came from an MCP server or an extension. It enters the same loop. The pipeline is the trust boundary. The individual tool is one stage inside it.","product-aura.a40692adbc":"ONE PIPELINE","product-aura.47cd48759a":"BUILT-IN OR EXTERNAL","product-aura.d058f8a8d3":"NO SECOND TRUST MODEL","product-aura.705208741b":"Where tools join","product-aura.2081fc59e2":"one ingress, one boundary","product-aura.999aa65230":"Built-in tools","product-aura.8863a055e6":"File, shell, Git, web, data, diff, patch.","product-aura.65dda5d140":"Registered tools enter the same path.","product-aura.656bcfe284":"Extensions","product-aura.8a8ab5f358":"Added tools inherit the same policy.","product-aura.9ecb6826eb":"many tools, one ingress","product-aura.658fd4ef0e":"the pipeline is the boundary","product-aura.f37a32db74":"A control boundary is only useful if it follows the code into every deployment.","product-aura.e596530748":"Deployment and custody","product-aura.e133b29e31":"Run the development loop","product-aura.fe9aa7dc5a":"where the code belongs.","product-aura.709cecaedf":"Aura runs as a native program on developer machines, controlled servers, containers, CI runners, and isolated infrastructure. Supported local models can keep inference inside the environment. Cloud backends remain optional and visible. The team chooses which content may leave and which tools may reach the network.","product-aura.ab2b08fae7":"With a supported local backend, model inference can remain inside the chosen environment. When a cloud model is selected, only the content Aura sends leaves the local runtime under the configured policy.","product-aura.2746c57f17":"FOUR POSTURES","product-aura.24ca1f0f39":"LOCAL INFERENCE OPTION","product-aura.7fc3c4bb8b":"OUTBOUND BY POLICY","product-aura.90fe9c81bc":"Posture and boundary","product-aura.1879f2c09f":"one unchanged loop","product-aura.ed91cd89f3":"Laptop","product-aura.c554a818b3":"A developer workstation.","product-aura.b67626b7bb":"CI runner","product-aura.f93ab00bad":"The same policy in the pipeline.","product-aura.75bc9d4470":"Private server","product-aura.2779d40a76":"Infrastructure the team controls.","product-aura.64a176e362":"Isolated","product-aura.60c5c028ed":"A supported local model, sealed sockets.","product-aura.8b20695218":"the posture changes","product-aura.8f04fdd695":"the development system does not","product-aura.1f35f77846":"The model can change without moving the development system.","product-aura.be117c51d2":"Model freedom","product-aura.cdde8b4725":"Change the model.","product-aura.3563fbfce7":"and keep the engineering loop.","product-aura.82780f528c":"Aura separates model reasoning from project execution. Supported cloud, private, local, and advisory backends can participate through one runtime. When enabled, routing can select among configured models by task complexity and capability. Fallback chains can preserve continuity after provider failure. The model node swaps; the tools, the policy and the audit record stay where they are.","product-aura.154b840dd4":"A capable frontier model can take a difficult architectural task, a cheaper model can take routine work, a local model can handle isolated code, and an advisory CLI can offer another perspective. Model choice becomes a runtime policy.","product-aura.e90770d213":"ONE RUNTIME","product-aura.f0ac63199f":"OPT-IN ROUTING","product-aura.6401350b99":"FALLBACK CHAINS","product-aura.8d047a149a":"The model node changes","product-aura.329651d4fd":"the rest of the loop does not","product-aura.0fed3b96cc":"Loom","product-aura.623de3060c":"Dweve cognition where selected.","product-aura.e3e091e7af":"Supported APIs","product-aura.a604ce0c20":"Anthropic, OpenAI-compatible, Mistral.","product-aura.125945b3bb":"Private endpoint","product-aura.2d05a79270":"A compatible local or hosted model.","product-aura.f528ea6654":"Advisory CLI","product-aura.78ee023f0d":"A read-only second opinion.","product-aura.591f4de4c2":"the model node swaps","product-aura.bc46b9b9ef":"tools, policy, audit stay","product-aura.f12a14dc0a":"The loop also needs to remember what the project has already taught it.","product-aura.95a50fffa4":"Continuity","product-aura.1a88b0152c":"A correction should stick","product-aura.81d2d1c6de":"not come back as a prompt.","product-aura.a6f84a3372":"Aura separates saved sessions from persistent memory. Preferences, project facts, learned patterns, and corrections can be recalled deterministically under a prompt budget. This is explicit project and runtime memory, not provider-side model training. Project instructions, custom agents, skills, prompts, and workflows can live on disk and reload while the session remains active.","product-aura.c1f8199919":"Recall uses deterministic relevance and BitRank over a bounded index, with SQLite FTS5 as the durable fallback. Memory is inspectable and manageable. A correction does not have to be repeated in every new session.","product-aura.9969840631":"DETERMINISTIC RECALL","product-aura.ea4d93b3a5":"INSPECTABLE","product-aura.5908484ef3":"REMOVABLE","product-aura.2afe021dea":"One correction, later reuse","product-aura.d02a4d3377":"reviewed, budgeted, deletable","product-aura.48e09e45c5":"Correct","product-aura.26995262e3":"The developer fixes a wrong assumption.","product-aura.0d8a7046c8":"Store","product-aura.7ab157d955":"It becomes a reviewed project memory.","product-aura.3f7e1fd914":"Recall","product-aura.890f373b43":"It ranks into a later plan under budget.","product-aura.03d5d80199":"Forget","product-aura.52e53246a1":"The developer can remove it at any time.","product-aura.0eceae53ab":"correct once","product-aura.f96a4686cf":"keep the correction","product-aura.d5f902e386":"One loop helps one developer. The same controls can coordinate several.","product-aura.05e1b61d51":"Coordinated scale","product-aura.e400f4a164":"More agents means capacity","product-aura.07e7caec9b":"not confusion.","product-aura.5f3dc09b6a":"Aura supports sequential chains, parallel runs, coordinated teams, and background tasks. Shared task boards, messages, quality gates, worktrees, and file-level claims coordinate the work. Aggregation remains explicit rather than hiding several contributors behind one anonymous answer.","product-aura.f07a10cb4a":"Parallel sessions can both be individually correct and collectively destructive if they edit the same file. The cross-agent work ledger tracks file-level claims, and dead-process claims can be reaped. Work can coexist.","product-aura.42932f36f3":"FOUR PATTERNS","product-aura.20d684d874":"FILE-LEVEL CLAIMS","product-aura.2950003a6b":"EXPLICIT AGGREGATION","product-aura.7db945a529":"Four patterns, one ledger","product-aura.9cd0b0d078":"no silent collision","product-aura.2b81308032":"Chains","product-aura.99147cf469":"One agent hands output to the next.","product-aura.afc129571b":"Parallel","product-aura.f20643e147":"Several agents run and aggregate.","product-aura.cbfd44d9c7":"Teams","product-aura.685f0eaf96":"A shared board, messages, quality gates.","product-aura.64dd60fe1a":"Background","product-aura.c02edef2e1":"Independent status and cancellation.","product-aura.684554c0d9":"two agents, one file","product-aura.5e0391be4e":"one claim is deferred","product-aura.f0e4c4d56b":"Several participants still need one record of what happened.","product-aura.e83d4dc14a":"Engineering record","product-aura.5da86d9570":"The diff shows what changed.","product-aura.e3fdef02c8":"the record shows how.","product-aura.76e3f48713":"Aura includes an append-only JSONL audit trail with BLAKE3 hash chaining. When enabled, observable events such as tool calls, routing, compaction, Guardian actions, file work, and session transitions can be recorded in order and later verified for post-hoc modification.","product-aura.1094ee6bbb":"The trail is tamper-evident, not a claim of legal immutability. Changing or deleting an entry breaks the chain from that point onward. Incident review becomes a replay of the recorded work rather than an argument about what the agent probably did.","product-aura.b75b732fb4":"APPEND-ONLY JSONL","product-aura.9068512079":"HASH-CHAINED","product-aura.08f4352e62":"TAMPER-EVIDENT","product-aura.1c013851a3":"What the record holds","product-aura.f9c6b8eb36":"assembled as the work runs","product-aura.d51238236e":"Model routes","product-aura.f7d00913e4":"Which backend produced which decision.","product-aura.46de02cbcd":"Tool calls","product-aura.90c944b0bb":"Arguments, results, and outcomes.","product-aura.2145feeadf":"Guardian actions","product-aura.b4a4ba845f":"Corrective hints and stops.","product-aura.03128bed90":"Verification","product-aura.d91d9336d1":"verify-audit checks the chain.","product-aura.f2b92fded8":"alter one entry","product-aura.0b089f9215":"every later link breaks","product-aura.6f1a2701f8":"The record supports review. Security controls shape what is allowed to enter it.","product-aura.5845b37156":"Guard the action, the content,","product-aura.239329c1d0":"and the environment.","product-aura.0caa906af5":"Aura layers tool permission and shell analysis, content filtering and redaction, and infrastructure scope and network policy. The controls can be tightened per project, session, or environment. They provide enforceable technical boundaries and evidence for review without claiming automatic legal compliance.","product-aura.8c7c653f99":"Shell structure is analysed before execution, filesystem paths are contained, supported PII and secret patterns are redacted, prompt injection is detected, and repeated failures are isolated. These controls support security and regulatory review. They do not create a certification badge.","product-aura.0d8f9e703d":"ACTION LAYER","product-aura.896036d910":"CONTENT LAYER","product-aura.7aa5cf4c2c":"INFRASTRUCTURE LAYER","product-aura.7401769d23":"Three layers, one call","product-aura.41bb1b6470":"each with a concrete control","product-aura.97c89a4d66":"Action","product-aura.f83f092dbc":"Permission and shell analysis.","product-aura.4f9be057f0":"Content","product-aura.c14d461401":"Filtering, redaction, injection detection.","product-aura.951d9aa32b":"Infrastructure","product-aura.3da3e815d7":"Scope, session allowlists, network policy.","product-aura.b8b04a82bb":"controls reduce risk","product-aura.de8fa2c6fa":"they do not eliminate it","product-aura.265fb840a4":"The whole system ships as one runtime, not a pile of enforcement services.","product-aura.383a31c392":"Native runtime","product-aura.e1df517bfe":"The missing middle,","product-aura.a533b91889":"in one Rust program.","product-aura.d0188ba9b5":"Aura combines the terminal interface, model adapters, tool system, security layers, memory, audit trail, workflows, and orchestration in one native binary. Optional providers, MCP servers, advisers, compilers, and test tools remain external where selected.","product-aura.8a11f068e7":"Teams often assemble a coding assistant, code search, memory plugin, security wrappers, quality scripts, audit logging, and multi-agent coordination from separate products. The team operates one development control model rather than assembling one from unrelated services.","product-aura.b18a456009":"ONE BINARY","product-aura.8edf38166b":"NO PYTHON OR NODE CORE","product-aura.80d94208f3":"ONE CONTROL MODEL","product-aura.3944641c5c":"Modules as loop parts","product-aura.ac860bf7dd":"not file-count breadth","product-aura.ea1d3df298":"Control","product-aura.c8b7baadd9":"Outer loop, inner loop, Guardian, judge.","product-aura.f3798f81c7":"Models","product-aura.c9eda68459":"Adapters, routing, fallback.","product-aura.a725020675":"State","product-aura.61eda66443":"Memory, context, checkpoints.","product-aura.7ea014de7b":"Evidence","product-aura.d25dcde441":"Quality, audit, coordination.","product-aura.7f8794097a":"one deployable program","product-aura.caf114ae5c":"not services to assemble","product-aura.155e132b0e":"It still needs to fit the systems the team already uses.","product-aura.00ab623630":"Any editor. Your CI.","product-aura.7ec4725edd":"Your tools. One loop.","product-aura.120fa5c329":"Aura is terminal-native rather than editor-locked. It can connect to supported MCP servers, expose extension tools and commands, run project workflows, and operate in CI with structured output. It composes with the environment rather than requiring a proprietary development surface.","product-aura.09041f972f":"The terminal already sits beside the code, shell, Git history, test runner, package manager, and CI scripts. Any editor can remain the editor. Aura runs the development loop beside it.","product-aura.9675db2f39":"TERMINAL-NATIVE","product-aura.cf4fa94802":"MCP AND EXTENSIONS","product-aura.926c214ce9":"CI-READY OUTPUT","product-aura.671c879449":"What surrounds the loop","product-aura.5ea87e08e4":"the loop stays central","product-aura.c7e9fb2ea6":"Editor","product-aura.c9869651f8":"Keep the editor you already prefer.","product-aura.13844228ea":"CI","product-aura.fb2cc2380f":"Run the same goal and quality policy.","product-aura.9ccb9ad751":"Registered tools enter the boundary.","product-aura.f7d513fd94":"Git host","product-aura.94282271db":"Durable source control stays in place.","product-aura.bfb8c8751d":"composes with the estate","product-aura.8af76d1f1f":"no proprietary surface","product-aura.b2982e878d":"Bring one open-loop workflow and give Aura the definition of done.","product-aura.26b2e09644":"Give Aura the goal, the boundary, and the definition of done.","product-aura.e42c4ee7ea":"Bring one development task that currently bounces between a coding assistant, a developer, the test runner, a reviewer, and a set of scripts. Define what success means, which tools are allowed, and which quality gates matter. Watch the loop run against the real repository.","product-aura.161480a2d3":"Read the architecture","product-aura.9e3c1d591d":"What the claims stand on","product-aura.356a192b79":"1","product-aura.a2e7ed6972":"One deployable runtime, no Python or Node core","product-aura.368ace5e66":"25+","product-aura.70eeac5cf5":"built-in tools","product-aura.9b7c024522":"File, code, shell, Git, web, data, through one pipeline","product-aura.f1abd67035":"15","product-aura.87aa808c22":"stage tool pipeline","product-aura.6c8c4fd83e":"Scope, permission, checkpoint, sanitise, audit","product-aura.63cea569e5":"BLAKE3","product-aura.ac0f9e6164":"hash-chained audit","product-aura.33ad4db552":"Tamper-evident record, deterministic goal checks","product-aura.932696a96c":"Dweve Aura, autonomous development runtime","product-aura.25d170c127":"The model is not the agent.","product-aura.2c9fdd89a3":"The loop is the agent.","product-aura.8498fbfde1":"Aura is a Rust-native AI coding agent runtime with a closed loop. The outer loop owns the objective and replanning; the inner loop executes one bounded tool action at a time. Memory, policy, checkpoints, quality and audit remain outside the model and inside the runtime.","product-aura.de0733740b":"Live loop state","product-aura.1fdf175152":"RUNTIME","product-aura.a60792e996":"Outer loop","product-aura.f9f2c60cd6":"objective and replan","product-aura.0dfd4db698":"Inner loop","product-aura.895cdc61d1":"one bounded action","product-aura.6809e8745e":"Guardian","product-aura.9042f1969d":"watches loop health","product-aura.62092270ca":"Goal judge","product-aura.0a021d821b":"executable completion","product-aura.336de2696c":"Every action","product-aura.025b5f19e8":"tamper-evident record","product-aura.9a660aa079":"Start with the architecture that keeps those states coherent.","product-aura.c5050180fa":"Runtime architecture","product-aura.98436279c7":"One process.","product-aura.c6a2b83c4d":"Separate control systems.","product-aura.0c534596ec":"Aura compiles the TUI, coordinator, LLM layer, tool manager, security, memory, audit, workflows, registry, and state systems into one native program. Modules remain separated by typed contracts and events rather than being collapsed into one monolith of shared mutable state.","product-aura.21c5dea3a7":"That separation is what makes provider choice possible without rebuilding the agent around each provider SDK. The runtime remains one binary while the modules remain independently testable.","product-aura.d7c805806e":"TYPED CONTRACTS","product-aura.153cd474b1":"INDEPENDENTLY TESTABLE","product-aura.4de1d755eb":"Modules by loop role","product-aura.a6d3e37540":"grouped by responsibility","product-aura.c92440717d":"Observe and Plan","product-aura.45b50457f1":"LLM layer, coordinator, state store.","product-aura.cfc043eca7":"Act and Control","product-aura.c30fa654ba":"Tool manager, security, permissions.","product-aura.8cde59838c":"Coordinate","product-aura.b21c3d1e9a":"Agent registry, background workers.","product-aura.f2fd050588":"Present and Record","product-aura.cf305fb322":"TUI renderer, audit trail.","product-aura.6a1f36237f":"one process","product-aura.3c50d77f08":"not one shared-state monolith","product-aura.5e41b4f465":"The typed event bus is the circulation system.","product-aura.ffb2616892":"Coordination","product-aura.aa0a246125":"State changes once.","product-aura.0bb6a8889e":"and every subsystem sees it.","product-aura.7b752b2e2d":"The renderer, event handler, LLM orchestrator, tool manager, state store, agent registry, Guardian, background tasks, and audit hooks communicate through typed pub and sub. Cross-cutting behaviour can observe the run without hard-wiring every module to every other module. One event reaches many observers: the interface renders it, the audit chain appends it, the metrics counter tallies tokens and turns, the Guardian watches for stalls, and the task state tracks the plan. A new observer subscribes without touching the publisher.","product-aura.b7e78dd7af":"The interface can update while a model streams, a tool runs, a Guardian event fires, or a background task changes state. The bus carries two nested loops and one independent watcher.","product-aura.8b30f5ff84":"TYPED PUB-SUB","product-aura.cf9ee183a4":"NO HARD WIRING","product-aura.30d820a7b8":"STREAM-SAFE UI","product-aura.67205a8813":"One event, many observers","product-aura.027d20e79d":"type names, not anonymous arrows","product-aura.966b973401":"metrics","product-aura.11633d4b96":"task state","product-aura.ff432b467f":"extensions","product-aura.5394dc99d0":"state changes once","product-aura.f6c17fb25e":"the interested observe it","product-aura.17b738373f":"The bus carries two nested loops and one independent watcher.","product-aura.8b4c311b0b":"The objective survives","product-aura.6d79deb916":"the model turn.","product-aura.d4da5eec25":"The outer loop owns session context, goal state, plan, follow-up continuation, completion checks, and the decision to replan. A tool result or user correction can invalidate the current plan without discarding the objective.","product-aura.fb96a5c680":"When the goal judge says the success criteria are unmet, the outer loop has a concrete reason to continue. When the user changes direction, it incorporates the new instruction instead of pretending the original plan is still authoritative.","product-aura.302ed3025e":"OWNS THE OBJECTIVE","product-aura.0bbd33fcc0":"PLAN VERSIONS","product-aura.9b596abf1d":"REPLAN ON STATE","product-aura.85835bdc5a":"Plan, execute, judge","product-aura.5316299897":"continue or replan","product-aura.b52e2e2da9":"Resolve the work from the objective.","product-aura.6ea36ce8d4":"Execute","product-aura.a814f84078":"Hand each step to the inner loop.","product-aura.e50f87b280":"Check the result against the criteria.","product-aura.1feaee9272":"Continue or replan","product-aura.331dfeb77d":"Decide from the observed state.","product-aura.465416cea5":"the objective persists","product-aura.c769d07232":"longer than one response","product-aura.aa137dc412":"The inner loop turns each plan step into observed state.","product-aura.f373f05106":"One bounded action","product-aura.e7c325926b":"at a time.","product-aura.a3994f90f7":"The inner loop parses the model tool call, validates it against the schema and policy, executes it with timeout and progress handling, filters the result, and feeds the observed output into the next decision. Mid-turn steering can modify that decision before the next action.","product-aura.5003a633eb":"The next step is based on what the tool actually returned, not on what the model expected it to return. That difference is the beginning of a real control loop.","product-aura.f2bac0cf69":"VALIDATE, EXECUTE","product-aura.46b986b261":"OBSERVE THE RESULT","product-aura.e821aa5033":"STEER BETWEEN STEPS","product-aura.60476d8dcf":"A step, then a correction","product-aura.083534100f":"the pending action changes","product-aura.852b438f91":"Read","product-aura.7c178241c8":"A bounded tool call is validated.","product-aura.bbb43342f1":"A user message enters between actions.","product-aura.190aa84247":"Patch","product-aura.18f324a5e0":"The next step changes before execution.","product-aura.8638f86a86":"observed output","product-aura.248dacd762":"not expected output","product-aura.711b59e08e":"The model and user are not the only observers.","product-aura.26853a3144":"Guardian watchdog","product-aura.44f011fef8":"An agent should not be","product-aura.a06b0eb710":"its only supervisor.","product-aura.5e827c3485":"The Guardian monitors configured signals for repeated actions, stalls, and budget overruns. It can inject corrective feedback or trigger the configured stop path. It operates outside the inner planning narrative, so the model does not grade its own loop health alone. Three detectors sit around both loops: repeat, stall, and budget.","product-aura.9c763256ff":"A development agent can fail without throwing an exception. It can repeat the same search, cycle between two edits, keep spending tokens without progress, or stall after a tool response. The loop has an observer.","product-aura.524d4a97c6":"REPEAT DETECTOR","product-aura.6632deea3e":"STALL DETECTOR","product-aura.3f461db852":"BUDGET DETECTOR","product-aura.27336e12fe":"Three detectors","product-aura.65da056cf7":"a halo around both loops","product-aura.659eba1219":"Repeat","product-aura.d1d21a6920":"A repeated grep sequence triggers a hint.","product-aura.516bb8e849":"Stall","product-aura.10cca4c955":"No progress after a tool response.","product-aura.7aeba4cd15":"Budget","product-aura.d918d030c1":"Token spend crosses the configured bound.","product-aura.c79e67d681":"loop health says continue","product-aura.557181a432":"the judge says complete","product-aura.933ca9896e":"Loop health says whether to continue. The goal judge says whether the task is complete.","product-aura.ef6526de6b":"Goal state","product-aura.f3f3ac2a08":"Completion is a predicate,","product-aura.18cac7c221":"not a paragraph.","product-aura.30cad16313":"Aura supports declarative criteria for substring, regular expression, file existence, and test pass. The deterministic path runs first. The optional model judge handles criteria that need interpretation. The result is explicit: satisfied, unsatisfied, or inconclusive under the selected policy.","product-aura.9abd576f33":"A test result, file existence check, substring, or regular expression does not need another expensive model call. Only the ambiguous cases need the optional model judge. The judgement becomes part of the session record.","product-aura.1f270b044e":"MODEL LANE OPTIONAL","product-aura.a7d9749fee":"EXPLICIT VERDICT","product-aura.9cc76abb8d":"Two evaluation lanes","product-aura.e6aebdc66e":"exact inputs and verdicts","product-aura.bf243ddcf2":"Test pass","product-aura.e1879a7155":"Deterministic. No model call.","product-aura.c3dd984fe3":"Substring or regular expression.","product-aura.d746ca45b7":"Interpretive","product-aura.8ed132d051":"Routed to the optional model judge.","product-aura.3f668df050":"satisfied or unsatisfied","product-aura.29d5cc2af9":"or inconclusive by policy","product-aura.4797d9bfc0":"The judge depends on trustworthy feedback from the action layer.","product-aura.cd6c28666e":"Operator control","product-aura.4633d122bc":"Interrupt the decision","product-aura.2fcf1f2398":"before it becomes a mistake.","product-aura.e44aa92396":"Streaming output, a steering queue, cooperative abort handles, task cancellation, and explicit waiting states keep control live while work proceeds. The runtime does not assume that the original prompt remains the final source of authority.","product-aura.18b2536a02":"A stream is interrupted between tool calls, the pending step is replaced, and the audit record notes the steering event. The correction enters the next decision while the relevant context is still active.","product-aura.28ee97fd4b":"STEERING QUEUE","product-aura.63abfd12a5":"COOPERATIVE ABORT","product-aura.c6aad77437":"EXPLICIT WAITING","product-aura.53959a91f1":"Control while it runs","product-aura.d8bdbe8d9c":"the prompt is not final authority","product-aura.387c22c7cc":"Output flows as the model produces it.","product-aura.ea6ed18c10":"A queued message redirects the next step.","product-aura.7d87f7d6c1":"A cooperative handle stops the run.","product-aura.34dbd5c4c8":"Wait","product-aura.e1010e39ef":"An explicit state pauses for approval.","product-aura.dab6ae89b9":"the stream is interruptible","product-aura.d357e856e4":"the step is replaceable","product-aura.b4636a2058":"Every action then enters the same tool boundary.","product-aura.3a4c2e8755":"The tool call is not the boundary.","product-aura.e60c224e20":"The pipeline is.","product-aura.699d8bcf47":"A tool call passes staged handling before and after the core operation: normalisation, circuit breaker, scope, enablelist or denylist, permission, bash analysis, file policy, checkpoint, cache, execution, cache update, output filter, sanitisation and redaction, audit, and breaker update.","product-aura.9b473caeab":"Run one patch call and one MCP call through it. Some stages are a no-op for a given tool and others produce decisions. The pipeline is the trust boundary. The individual tool is one stage inside it.","product-aura.1fe81fb1d9":"FIFTEEN STAGES","product-aura.026be34b47":"BEFORE AND AFTER","product-aura.bd22e2019b":"THE TRUST BOUNDARY","product-aura.5c7f872a9f":"Two tools, one pipeline","product-aura.4527cf6916":"which stages decide","product-aura.6e66568583":"Guard","product-aura.17e8e687b4":"Normalise, breaker, scope, permission.","product-aura.2f4240de4d":"Prepare","product-aura.bf7eafdb32":"Bash analysis, file policy, checkpoint, cache.","product-aura.b1b392607d":"Run","product-aura.f7feec0ad3":"Execute with timeout and progress.","product-aura.3ebe66ce7c":"Settle","product-aura.3b5f38059f":"Filter, sanitise, audit, breaker update.","product-aura.c46d33ba06":"the tool is one stage","product-aura.ede67c8e36":"Permission and scope are resolved before the tool sees the project.","product-aura.50537577cd":"Tool policy","product-aura.786d77a928":"Always, Ask, or Never,","product-aura.7bf5421e34":"by tool and context.","product-aura.822d80feb2":"Tool-level defaults, project overrides, session allowlists, enablelists, denylists, and filesystem scopes define autonomy as a capability matrix rather than one global mode. Out-of-scope paths can be routed to approval instead of silently widened.","product-aura.f399a6c7a5":"The developer can loosen a session without permanently widening every future run. Autonomy is not one global switch. It is a set of explicit permissions attached to real actions.","product-aura.465162539b":"ALWAYS, ASK, NEVER","product-aura.08c55acf01":"FOUR POLICY LAYERS","product-aura.1b37a93eea":"SCOPED PATHS","product-aura.3dc231d6fe":"The permission matrix","product-aura.d4be6fb5b7":"tools across layers","product-aura.f6f4da8d93":"Project","product-aura.4f8edf6056":"The repository policy for each tool.","product-aura.4a913f4006":"Personal defaults beneath the project.","product-aura.f7f1997c6c":"Session","product-aura.9e19c2fcab":"A temporary allowance for one run.","product-aura.3b124af4ca":"One override for one CI job.","product-aura.50796d635b":"a capability matrix","product-aura.1408516e64":"not one global mode","product-aura.79b594d0f5":"Shell execution receives an additional structural review.","product-aura.d0f09dbbe0":"Bash analysis","product-aura.4b412763fa":"Review the command structure,","product-aura.56033de7df":"not just the string.","product-aura.07bbe3365d":"The BashAnalyzer tokenizes commands and shell operators with quoting and escaping awareness, then classifies risk. Dangerous execution shapes can require approval or be blocked, while quoted examples avoid simple substring false positives.","product-aura.499ed1d5d5":"A shell command is not safe merely because it looks familiar as text. A quoted example containing dangerous words is not treated the same as an executable destructive command. The policy follows structure rather than a brittle substring list.","product-aura.4d9d3aa65c":"TOKENISED","product-aura.7a935f182e":"RISK CLASSIFIED","product-aura.ccd066e703":"STRUCTURE, NOT SUBSTRING","product-aura.ada4ab4607":"Three commands, three verdicts","product-aura.ffd6e3bfb3":"the AST decides","product-aura.c2bc6b2ac7":"A safe command","product-aura.d2516f38f6":"Runs under the configured policy.","product-aura.c931ac882e":"A quoted string","product-aura.93d893821a":"Dangerous words in quotes stay safe.","product-aura.c0970dc342":"A pipe to shell","product-aura.d9da98c350":"A real destructive shape is stopped.","product-aura.0223141a7d":"tokens and operators","product-aura.5dca93cfe3":"quoting and escaping aware","product-aura.c170734c5d":"The feedback channel also needs protection from untrusted content.","product-aura.5db46ab7be":"Content boundary","product-aura.4b09f3cadc":"Tool output is data,","product-aura.ad29b37310":"not instruction.","product-aura.2c8d85eb41":"Aura can truncate oversized output, strip control characters and terminal noise, detect prompt-injection patterns, fence web-origin content, and redact supported PII and secret formats before the result re-enters model context.","product-aura.edfb83d1b2":"Tool output can contain secrets, terminal control codes, duplicated lines, or instructions intended to hijack the next model turn. The model does not receive raw external content merely because a tool returned it. The loop protects its own feedback channel.","product-aura.5b6a028bc9":"STRIP AND FENCE","product-aura.9c3e3c1909":"INJECTION DETECTED","product-aura.7d52614756":"PII AND SECRETS REDACTED","product-aura.4e7cb8d59d":"Raw to filtered","product-aura.e4f54f51a4":"what the model never sees","product-aura.a3dd8a5de5":"ANSI removed","product-aura.795e1314e4":"Terminal control codes are stripped.","product-aura.1f12bdb281":"Web content fenced","product-aura.f379227dec":"Web-origin text is wrapped as data.","product-aura.22b6b6fb71":"Injection flagged","product-aura.9fe801f74a":"A hijack pattern is detected.","product-aura.5406fbef02":"Secrets redacted","product-aura.fa92712504":"Supported PII and secret formats masked.","product-aura.15688d02bb":"untrusted stays untrusted","product-aura.8c2f3e8e0c":"fencing is not trust","product-aura.04bdf24cb6":"A clean feedback channel still needs failure memory.","product-aura.f860e899dc":"Do not let one broken tool","product-aura.bfa2e25e0e":"consume the whole loop.","product-aura.23f887366b":"Per-tool sliding windows track success and failure. A failing tool can open its circuit for cooldown. Deterministic read-only tools can use the LRU cache, while writes invalidate affected entries. The runtime avoids retry storms and repeated reads the project state has already answered.","product-aura.45b9aa3268":"The loop remembers both success and failure at the tool boundary. The agent receives cleaner, smaller feedback and avoids re-running work the runtime already knows.","product-aura.885cd293c9":"PER-TOOL WINDOWS","product-aura.97797f4bcc":"CIRCUIT COOLDOWN","product-aura.844d8c318c":"CACHE INVALIDATION","product-aura.c4651476ca":"One circuit, four states","product-aura.20d348f15d":"a cache entry invalidates","product-aura.88d86b7721":"Closed","product-aura.a57562ff8f":"The tool runs normally.","product-aura.cf9b77061f":"Open","product-aura.e04c9f4b3c":"Repeated failure blocks further calls.","product-aura.c4b2bd7e33":"Half-open","product-aura.4d42336d3c":"A trial call tests recovery.","product-aura.0bde7e3616":"Invalidate","product-aura.a624ebf6b5":"A patch clears the affected cache entry.","product-aura.8efa299af0":"no retry storm","product-aura.95fb2286f9":"no repeated reads","product-aura.0aebbd03e9":"Writes also receive a recovery path before execution.","product-aura.51e1e85d3d":"Change isolation","product-aura.3871ea3003":"Immediate undo, isolated work,","product-aura.7ec7536f4c":"durable history.","product-aura.0542837023":"Supported write tools capture checkpoints for live undo. Worktrees isolate larger or parallel tasks. Git remains the durable source-control layer. Aura uses all three rather than pretending one recovery mechanism solves every timescale.","product-aura.7285221201":"Checkpoints retain up to the configured capacity, currently up to 50 levels in the implementation overview. Undo is not Git history. The three mechanisms are distinct and are used for the job each suits.","product-aura.1e2a15910f":"CHECKPOINT UNDO","product-aura.205ccf3957":"WORKTREE ISOLATION","product-aura.aba1b3c9b4":"GIT IS DURABLE","product-aura.2d70a327d0":"Three layers, three timescales","product-aura.93a4f7db57":"scope and recovery use","product-aura.5cb9afc059":"Checkpoint","product-aura.4266f2f766":"Immediate undo before and between commits.","product-aura.fad0554cb2":"Worktree","product-aura.f6b9c137fa":"Isolate larger or parallel efforts.","product-aura.ab9c19e546":"The durable source-control system.","product-aura.f7d91370c3":"finer than a commit","product-aura.3aa1bddb4f":"not a replacement for Git","product-aura.c95c2dc4df":"The loop also needs to survive long context and future sessions.","product-aura.00a7561646":"Context budget","product-aura.828f3cd0cd":"Compaction changes behaviour,","product-aura.8359eee6de":"so record it and control it.","product-aura.35b1860f10":"Streaming, token tracking, budget thresholds, deferred summaries, stale-output pruning, and full compaction maintain a bounded working set. File read and write awareness is preserved across compaction where supported. Each compaction is itself recorded as an audit event, so the working set can be reconstructed later.","product-aura.f1a98cc8c1":"The model receives a bounded working set rather than an indefinitely growing transcript. Compaction is recorded as an event because changing context changes the next decision.","product-aura.e69e6f4054":"BUDGETED STATE","product-aura.900ed39e56":"STAGED COMPACTION","product-aura.e5532330b7":"RECORDED AS EVENT","product-aura.d84a9d7d23":"Content across a threshold","product-aura.1f79fa4de0":"summarised, pruned, retained","product-aura.03bf678ac8":"Summarise","product-aura.9aab8e3483":"Deferred summaries preserve meaning.","product-aura.2f24ebaee0":"Prune","product-aura.53c764f0af":"Stale tool output is removed.","product-aura.d6b58574b7":"Retain","product-aura.2dccc4d2a5":"File-operation awareness is kept.","product-aura.1c54132b8e":"Record","product-aura.fb66a40cde":"The compaction is an audit event.","product-aura.597d3f47d8":"a bounded working set","product-aura.faf60a49f7":"not a growing transcript","product-aura.89922e5964":"Conversation state is not the same as persistent memory.","product-aura.b5b60bfcec":"Cross-session memory","product-aura.305330104c":"Remember corrections locally","product-aura.a2d2d4ca82":"not at the provider.","product-aura.6ea39ff60b":"Aura persists user preferences, project context, learned patterns, and corrections in SQLite. Recall uses deterministic relevance and BitRank over a bounded lexical index, with FTS5 as durable fallback, then trims to the prompt budget. Users can add, search, list, forget, and inspect memory.","product-aura.3e526249f6":"Saved sessions preserve the conversation. Persistent memory preserves selected facts across sessions. Recall uses deterministic ranking and bounded injection rather than blindly appending every stored fact.","product-aura.421dbccc3a":"SQLITE BACKED","product-aura.417651a285":"BITRANK RECALL","product-aura.ae4f27c469":"USER-MANAGEABLE","product-aura.d5866c13f5":"Session one to session two","product-aura.78f968f3d0":"a visible prompt budget","product-aura.60c8f1a00d":"A correction is stored in session one.","product-aura.c1d8faaabc":"It ranks for session two by relevance.","product-aura.e8f8bc5890":"It enters the prompt under a budget.","product-aura.1accffa480":"The user can remove it directly.","product-aura.a7e96289a2":"deterministic relevance","product-aura.85648dd3dc":"FTS5 durable fallback","product-aura.a774004025":"The model layer can therefore remain replaceable.","product-aura.6b47f95870":"Backend layer","product-aura.7cc811cdc4":"Normalise the model.","product-aura.54971a2f84":"Preserve its capability differences.","product-aura.63f9e5557a":"Native API backends, compatible API shapes, custom model entries, streaming, rate limits, capability metadata, complexity routing, and fallback sit behind one Aura interface. The runtime records which model and route were used without pretending every provider supports the same tools, context, or thinking modes.","product-aura.9085993c2c":"Native paths include supported Anthropic, OpenAI-compatible, Mistral, and Anthropic-compatible providers. Advisory CLIs remain read-only advisers. Aura applies accepted changes through its own tools. When enabled, the router can select the cheapest configured model that meets the capability requirement.","product-aura.c6eb343fa9":"NATIVE AND COMPATIBLE","product-aura.d1efe54bfb":"OPT-IN ROUTER","product-aura.9ab521a560":"ROUTE RECORDED","product-aura.2141b601d1":"Four backend shapes","product-aura.c7408bd258":"the opt-in router above","product-aura.dcb9d4335f":"Native API","product-aura.d87dd779b6":"Supported providers with native paths.","product-aura.c315c6cdc0":"Compatible API","product-aura.fcc35e9f38":"Compatible shapes and custom entries.","product-aura.55d5ff8623":"Local or private","product-aura.a7e2988bc7":"A supported endpoint you control.","product-aura.47e75daab6":"CLI advisory","product-aura.8bdbf450b3":"Read-only advisers, no write authority.","product-aura.cbcdf92347":"the model is normalised","product-aura.f760cd8c38":"its capabilities are preserved","product-aura.bc3e0ec141":"Project files define how those models should behave here.","product-aura.7ef33643f3":"Configuration as code","product-aura.c80020edfd":"The repository can teach","product-aura.15de11db70":"the agent how to work.","product-aura.4f297b6a05":"Compiled defaults, user configuration, project configuration, and environment overrides merge by key. Instruction files, model definitions, tool policy, agents, skills, prompts, themes, and workflows can live on disk and hot reload. Every effective value shows which layer supplied it, as a live diff.","product-aura.17054fdacc":"A developer can keep personal defaults, a repository can define its own policy, and CI can override one value for one run. Hot reload rebuilds the effective prompt and configuration without discarding the active session.","product-aura.f55349d6d5":"FOUR LAYERS, MERGED","product-aura.365ddd48be":"ENVIRONMENT OVERRIDES","product-aura.6eebb606b5":"Which layer supplied it","product-aura.4532157aa8":"a live effective-value diff","product-aura.2f4a9f4ffb":"Compiled defaults","product-aura.2134940dde":"The built-in baseline.","product-aura.fffc9ab878":"Personal defaults on top.","product-aura.5f290b06ec":"The repository policy.","product-aura.210379f7ed":"One override for one run.","product-aura.3467acb8b8":"layers merge by key","product-aura.c278776751":"the effective value is visible","product-aura.d287214233":"Agents and workflows are ordinary reviewed artefacts.","product-aura.b7df0ccc43":"Review the development process","product-aura.8b3c014afc":"in source control.","product-aura.ae71a74c79":"Markdown and YAML definitions can describe agents, chains, skills, and prompts. Built-in, user, and project tiers merge by precedence. DAG workflows define repeatable debug, feature, optimisation, refactor, and review processes without rebuilding Aura.","product-aura.4f2920bcfb":"An agent definition can name the role, model, tools, instructions, and success conditions expected from that specialist. The files are reviewable, versionable, and portable with the project. The project does not lose its agent design when one workspace is closed.","product-aura.35b703ec4f":"MARKDOWN AND YAML","product-aura.546d623d25":"MERGED BY TIER","product-aura.92316d714d":"A file tree to a workflow","product-aura.724b61478e":"hot reload updates the session","product-aura.64acf7e2a7":"Agents","product-aura.70c0dd04da":"Role, model, tools, success conditions.","product-aura.e09212c7d3":"Skills","product-aura.8f634a8f87":"Conditionally injected fragments.","product-aura.eea5311d72":"Prompts","product-aura.11e508f2cb":"Templates that resolve project variables.","product-aura.5c02661f86":"DAGs for debug, feature, refactor, review.","product-aura.000ccd083f":"specialists are files","product-aura.4054b11fd1":"reviewed in source control","product-aura.bd65399346":"The same explicit structure scales to several agents.","product-aura.0d91315065":"Concurrency is easy.","product-aura.83d9aca695":"shared code is the hard part.","product-aura.7a6f7faab3":"Chains, parallel execution, teams, and background tasks define distinct coordination patterns. Task boards, message buffers, aggregation strategies, quality gates, worktrees, and file-level claims keep the shared repository state visible. When two agents reach for the same file, the ledger defers one claim rather than letting both write.","product-aura.5a00023156":"Parallel output may use first-success, all-complete, vote, or configured merge behaviour. File claims coordinate Aura sessions and dead-process claims can be reaped. The orchestration structure stays inspectable rather than hiding several agents behind one voice.","product-aura.5e0fa31bbb":"NAMED AGGREGATION","product-aura.6c8df1cada":"Ordered handovers with error policy.","product-aura.b3fb3cd12e":"Concurrency and an aggregation strategy.","product-aura.14508572dd":"Shared tasks, messages, quality gates.","product-aura.cfa219e442":"Independent lifecycle and cancellation.","product-aura.ff4e5c68b8":"the ledger defers one","product-aura.1bc82b0c8f":"External capability can join without bypassing the loop.","product-aura.7b9f8d7a06":"External capability","product-aura.0c177dba22":"Discover more tools.","product-aura.ba0d4a22fe":"Keep one trust boundary.","product-aura.f1ed0144d8":"Aura connects to supported MCP servers over stdio JSON-RPC 2.0, negotiates capabilities, and registers tools, prompts, and resources. A trait-based extension API can add tools, slash commands, and event handlers. Registered capabilities enter the policy and observation path while the remote server behaviour remains an external boundary.","product-aura.7f7be156f7":"External capability is not trusted merely because it is discoverable. A discovered MCP tool appears in the registry and can pass through the same permission, audit, sanitisation, and failure-handling path as built-ins where the integration supports those controls.","product-aura.0339525415":"STDIO JSON-RPC 2.0","product-aura.95976a4a3d":"CAPABILITY NEGOTIATION","product-aura.e6c846ab39":"SAME BOUNDARY","product-aura.41410a82a4":"Handshake to audit","product-aura.74d79401a7":"the registration path","product-aura.76ccff916d":"Handshake","product-aura.791621dab2":"Typed MCP capability negotiation.","product-aura.d672995a14":"Register","product-aura.363d61bfa9":"Tools enter Aura registry.","product-aura.2444928438":"Assign","product-aura.0f4acc33c7":"A permission level is attached.","product-aura.058753c29e":"Execution appends to the record.","product-aura.a9190f8ebf":"the tool joins the boundary","product-aura.c7a4098c4b":"the server stays external","product-aura.791733e65d":"Every observable state transition can feed the engineering record.","product-aura.8c78f4c3b8":"Operational record","product-aura.92b865f5d0":"Every observable action","product-aura.88101b801c":"can join one verifiable sequence.","product-aura.66f62e1ac2":"Audit entries include a sequence, time, event kind, and previous-entry digest. Verification detects modification or deletion. The trail is a runtime record of actions and state transitions, not private model reasoning and not a blockchain.","product-aura.7657999f9d":"Each entry stores the BLAKE3 digest of the previous serialized entry. Changing or deleting an entry breaks verification from that point onward. It can support incident analysis and evidence export without being mislabeled as a formally immutable ledger.","product-aura.d0189e0bad":"PREVIOUS-ENTRY DIGEST","product-aura.e2a9946156":"PROVIDER BOUNDARY MARKED","product-aura.608fb8f008":"What the chain records","product-aura.4909c96bd2":"where hidden internals stop","product-aura.2b40d29ae4":"Tool calls and results","product-aura.3add8971fe":"Ordered and hash-linked.","product-aura.0073879ff7":"Routing and compaction","product-aura.55f11163a6":"Which model, which context change.","product-aura.a42e27f0c0":"Hints and stops, in sequence.","product-aura.d02414d78d":"Session lifecycle","product-aura.abf8c9c031":"Start, transitions, and finish.","product-aura.7851cb25d6":"tamper-evident","product-aura.2f4f94613b":"not immutable, not a blockchain","product-aura.e4d8ceb411":"Quality and CI turn that record into a repeatable engineering gate.","product-aura.1de7bbb542":"Repository feedback","product-aura.f365474e5f":"The repository","product-aura.24715ffda7":"gets a vote.","product-aura.1afb4a154f":"Project quality stages can run inside interactive sessions or CI. Structured output can feed existing pipelines and dashboards. Failures return to the loop as state rather than ending as a report the developer must manually relay.","product-aura.1ddb646e99":"Format, lint, compile, tests, documentation tests, and security audit improve confidence. Passing them does not prove absence of defects. Project policy decides which warnings block and which remain advisory.","product-aura.f1d9793391":"INTERACTIVE OR CI","product-aura.578109ed75":"STRUCTURED OUTPUT","product-aura.66160fabc4":"FAILURE AS STATE","product-aura.24d5ee5d4f":"Same policy, two surfaces","product-aura.c6b4353aa1":"comparable events","product-aura.108d3cf538":"Interactive TUI","product-aura.f6dba24972":"Runs the goal and quality policy.","product-aura.2fef4912e7":"Runs the same policy in the pipeline.","product-aura.cfcf9d34ba":"Structured output","product-aura.b90e7d44f9":"Feeds dashboards and gates.","product-aura.43e442f09c":"Loop feedback","product-aura.87e4d90232":"A failure returns as state.","product-aura.00f2398b69":"evidence, not proof","product-aura.ac2f995a8e":"policy decides what blocks","product-aura.8cfbad85b6":"The terminal makes all of those controls visible in one place.","product-aura.40730fd594":"Operator surface","product-aura.1a3d6e2cc0":"Not a prompt box.","product-aura.3faf2f0ab7":"but a live view of the loop.","product-aura.d6263745e9":"Tabs, chat, file tree, diff viewer, search, stats, settings, quality, tools, agents, skills, tasks, memory, goals, worktrees, and audit give the developer a keyboard-first view of state and control. Each panel maps to one loop responsibility, so the surface reads as a control console rather than a chat window.","product-aura.b8ad36628f":"The developer can move between conversation and execution without moving the project into a proprietary editor. The interface is a control console for the loop, not merely a terminal chat window.","product-aura.2131939241":"KEYBOARD-FIRST","product-aura.013ab19fdb":"STATE AND CONTROL","product-aura.125bcc839e":"ANY EDITOR REMAINS","product-aura.d2a14de957":"Panels by loop role","product-aura.c460f756b7":"each maps to a responsibility","product-aura.1a22c73406":"Chat and diff","product-aura.be72efa14b":"Reasoning, activity, proposed changes.","product-aura.9706a73909":"Files and search","product-aura.f71f20a365":"The project state, inspectable.","product-aura.fd9dc1bb17":"Quality and goals","product-aura.424ac1d3e0":"Feedback and completion state.","product-aura.1db53cf8b0":"Audit and tasks","product-aura.cc59efda9d":"History and background work.","product-aura.b49d84d38d":"a control console","product-aura.bed2e8dea5":"not a chat window","product-aura.f5f4b6a21d":"The same runtime can be built with different optional sensors and capabilities.","product-aura.7928973663":"Build surface","product-aura.e22d78e47d":"One loop,","product-aura.c7405e8379":"different capability sets.","product-aura.15d990dd18":"Default and feature-gated builds can include workflow, dashboard, context optimisation, Winnow web intelligence, Reed parsing, document RAG, sandbox variants, multi-agent coordination, and testing support. Deployment can target developer machines, containers, servers, CI, and isolated environments.","product-aura.50ba399b5b":"The core ships as one native Rust program. Public availability of feature-gated systems must match the distributed build. The loop remains the same even when the available sensors, tools, or participants differ.","product-aura.fc788ee8b2":"FEATURE-GATED","product-aura.f0d3cf7d43":"FIVE DEPLOY TARGETS","product-aura.ddac9b567c":"SAME LOOP CONTRACT","product-aura.717e14ecef":"Core loop, optional petals","product-aura.f302aa6fc3":"a profile selects a set","product-aura.5316d4c55f":"Web intelligence","product-aura.f15d6284a1":"Winnow, where the build enables it.","product-aura.b15987c5be":"Parsing and RAG","product-aura.e8665c8d2c":"Reed and document retrieval.","product-aura.03b989cc0a":"Sandbox variants","product-aura.476113c411":"Isolation options by build.","product-aura.f0bd90f002":"Multi-agent systems where enabled.","product-aura.75d0a84162":"the petals vary","product-aura.5421e683c7":"the loop contract holds","product-aura.104e1d1f03":"Leads into the close.","product-aura.5926d99943":"The first plan was wrong","product-aura.e4304c3646":"What state does the agent believe now?","product-aura.afeafc4d49":"A tool returned an unexpected result, and the user corrected the direction mid-run.","product-aura.78367ab385":"Context compacted after the fourth file, the same command failed three times, and the test suite still disagrees with done.","product-aura.1039119130":"Five things the transcript forgot","product-aura.538e56b690":"A tool returned the unexpected","product-aura.e898be703b":"The user corrected mid-run","product-aura.bbb140b2ef":"Context compacted after four files","product-aura.4fad0145b9":"The suite still disagrees with done","product-aura.43ae1af498":"An agent without a control loop is a script with confidence.","product-aura.20d573f308":"Give Aura a real repository and an executable definition of done.","product-aura.d521970923":"Set the objective, tools, scopes, model policy, quality stages, and success criteria. Watch the plan, actions, feedback, steering, replanning, judgement, and audit record against the actual project.","product-aura.4f5f94d2b4":"What the architecture stands on","product-aura.d999a2175d":"native single binary","product-aura.b5894a79de":"One process, typed modules, no Python or Node core","product-aura.acd20ee5d3":"2+1","product-aura.b02ac95bc1":"loops and a watcher","product-aura.00330bc8ef":"Outer loop, inner loop, Guardian, goal judge","product-aura.1f4525a70c":"Normalise, permission, checkpoint, sanitise, audit","product-aura.0b740a3f3f":"MCP stdio JSON-RPC 2.0, BitRank memory recall","product-aura.d97960fcce":"Dweve Aura, your development loop","product-aura.e35779fa87":"Writing the fix is the quick part.","product-aura.f4ac8da06d":"Checking that it worked","product-aura.9a1ab9d353":"is the rest of the job","product-aura.ec51541c8c":"Aura is an AI coding agent runtime for your project. Tell it what you want in plain language. It reads the relevant files, makes a plan, does only what you allow, and corrects the work when the result does not meet the goal. You can steer it, stop it, and undo supported changes at any time.","product-aura.f7b38f0719":"See how it works","product-aura.ca032b5844":"What it does","product-aura.13a37d11f4":"YOUR LOOP","product-aura.61b3a69d7e":"in plain language","product-aura.35fe3324d3":"It plans","product-aura.016368f102":"and shows the steps","product-aura.5fddb4c6ea":"It checks","product-aura.3bfe84cad0":"and fixes the failure","product-aura.c1df7f8f11":"You stay","product-aura.f1f801032d":"in command throughout","product-aura.2a1c048e93":"Start by telling Aura what done should look like.","product-aura.9e5e54c3e3":"Your request","product-aura.3a24d0ca08":"Describe the work,","product-aura.958e18997e":"not the steps behind it.","product-aura.4fb83f6ddb":"Ask why something keeps failing, where part of the project lives, or how a piece works. Ask Aura to add checks, build something new, or tidy up. It uses your files, project layout, instructions, and conversation, so you can start with the outcome instead of a list of commands.","product-aura.0bd1e8d63b":"Why does this keep failing? Where is login handled? Add tests for this function. Split this large file by responsibility. A useful goal says what done looks like.","product-aura.b838c172bb":"PLAIN LANGUAGE","product-aura.99b5a42533":"NO COMMANDS TO TYPE","product-aura.1d87c7f1b4":"YOUR PROJECT, NOT A DEMO","product-aura.ad96bab1aa":"Requests, not commands","product-aura.1c5a5311d1":"each becomes a small goal","product-aura.cf5119bdae":"Why does this fail","product-aura.747872ace6":"It reads the failing path first.","product-aura.7508e725d4":"Where is login handled","product-aura.a6c1e4c227":"It searches your project, not a guess.","product-aura.2b3ebb356c":"Add tests for this","product-aura.8d871b3161":"It plans the work before writing it.","product-aura.b3f20f3383":"Split this large file","product-aura.b7f7a76f13":"It proposes the change for approval.","product-aura.583201edd7":"describe the work","product-aura.e048014e5d":"Aura finds the steps","product-aura.45860458ca":"A useful goal says what done looks like.","product-aura.dd132f660f":"Goal mode","product-aura.759a42354b":"Done can mean","product-aura.220a406ffa":"the test passes.","product-aura.db68ae4524":"Aura can keep the task open until a supported condition is satisfied. You can require a test result, a file, a matching output, or another declared condition. It stops when the goal is met, when you stop it, or when it cannot continue honestly.","product-aura.0fad396593":"Done is not simply the last word in the chat. The task ends when its success conditions are satisfied, you stop it, or the system can no longer proceed honestly.","product-aura.4753e6584e":"A FINISH CONDITION","product-aura.d546b0a3b9":"STOPS FOR A REASON","product-aura.e5c0c16fbf":"HONEST WHEN STUCK","product-aura.396d15ce6e":"A goal, three criteria","product-aura.eb7d48916b":"with visible progress","product-aura.cbe4a21845":"The test passes","product-aura.f5a31b0a16":"Checked, not assumed.","product-aura.ab376617b2":"The file exists","product-aura.b8c1d34fae":"A required output is present.","product-aura.079dbe6966":"The output matches","product-aura.9af838e095":"A declared condition is met.","product-aura.f01fce7813":"done is a condition","product-aura.62d818d6b7":"not the last sentence","product-aura.256fe43957":"Before it acts, Aura reads the project state.","product-aura.d697757109":"Project context","product-aura.4c3844b074":"The answer starts in your code,","product-aura.eeb0e984d0":"not in a generic example.","product-aura.3ff4141b3c":"Aura can look through your files, follow how they connect, check what changed, read your project notes, and recall what you allow it to remember. It can point to the exact files behind the plan. The work starts in your own code rather than a generic example, and every plan names the files it read, so you can open them and check the reasoning before anything changes.","product-aura.97658c03cb":"It looks for the part that matters instead of asking you to paste the same background into every message. You can open the files, searches, and changes right where you work while it runs.","product-aura.919c7a3955":"SEARCH AND FILES","product-aura.08364aaf4b":"HISTORY AND NOTES","product-aura.60436b4ce9":"POINTS TO THE FILES","product-aura.76d1a87618":"What shaped the plan","product-aura.70e32efbd2":"within the access you allow","product-aura.6ce6c512ea":"Files","product-aura.d9c5b21aa2":"The relevant part, not the whole repo.","product-aura.bce0641417":"Search","product-aura.36b7afdbe2":"Where the feature actually lives.","product-aura.fa61242fe8":"Git state","product-aura.08a7ffe508":"The current branch and changes.","product-aura.ec453184b8":"One relevant project fact you kept.","product-aura.cce1f2b600":"starts in your code","product-aura.fcfd44bd3e":"points to the lines","product-aura.3060823e42":"Then it shows the route it wants to take.","product-aura.40392432eb":"See the steps","product-aura.43f3edc317":"before the work disappears.","product-aura.5a7d999a14":"Aura turns the task into an ordered plan. You can see which files it expects to read, which checks it intends to run, and which changes may need approval. The plan can change when the project returns new information. Each step shows its own progress, and the plan carries a version so you can tell when it moved.","product-aura.afcf390dac":"A five-step plan with visible progress and a plan version. You decide how much authority each action receives.","product-aura.8cdd599786":"AN ORDERED PLAN","product-aura.9dc635e294":"VISIBLE PROGRESS","product-aura.8c8fc4bd5a":"CHANGES WITH THE PROJECT","product-aura.68ec31f2dc":"A plan you can read","product-aura.4763101026":"before the work happens","product-aura.30f6e7afe6":"Which files it expects to open.","product-aura.64fbd995d3":"Change","product-aura.5acc572309":"Which edits may need approval.","product-aura.4b5e84be0e":"Check","product-aura.e69875e569":"Which checks it intends to run.","product-aura.9688fe26df":"Replan","product-aura.7a1b1006ae":"The plan version updates on new info.","product-aura.635788bbac":"the steps are visible","product-aura.3e3e346973":"not hidden in a wall of text","product-aura.2efecaaff7":"You decide how much authority each action receives.","product-aura.414559b287":"Run, ask, or never,","product-aura.4263998594":"tool by tool.","product-aura.a5d90c51a7":"Let safe reads run automatically. Require approval for file changes or commands. Disable the tools you do not want. Keep access inside the project unless you deliberately allow more. Every tool carries one of three settings: run automatically, ask first, or never.","product-aura.492cdda76c":"The default posture can remain conservative, then be loosened for a trusted project or one session. The settings are yours.","product-aura.36166d0df7":"THREE POSITIONS","product-aura.87529cc8f8":"PROJECT-SCOPED ACCESS","product-aura.e70b43e210":"CONSERVATIVE BY DEFAULT","product-aura.8e32d6c5a9":"A control per tool","product-aura.945f0635af":"the settings are yours","product-aura.a26f2cac33":"Let safe reads run automatically.","product-aura.3562777bc6":"Ask","product-aura.5655d3e49e":"Require approval for changes or commands.","product-aura.80c3052d33":"Never","product-aura.a9135f9444":"Disable the tools you do not want.","product-aura.256b35c754":"conservative by default","product-aura.d4056f2c4d":"loosened when you choose","product-aura.a9bdbe653c":"Control remains live after the run begins.","product-aura.584b188e9e":"Steering","product-aura.96783f8612":"Type the correction","product-aura.319cd01782":"before the wrong path is finished.","product-aura.8241e463b0":"Aura listens between actions. When a result reveals the wrong assumption, redirect the next step without starting a new session and re-explaining the project.","product-aura.73ab52f2d2":"You do not have to wait for a long run to finish, throw away the result, and start a new conversation. The correction enters the next decision while the context is still active.","product-aura.0577df086f":"LISTENS BETWEEN STEPS","product-aura.ba9327db65":"NO RESTART","product-aura.13fcbb5c1f":"CONTEXT STAYS WARM","product-aura.6cfac6c3b1":"A correction lands","product-aura.86e67126fa":"the pending step changes","product-aura.110949e002":"Aura is about to take a step.","product-aura.0d4e3779fb":"You type","product-aura.bb0c6912c7":"A correction enters between actions.","product-aura.55f513e367":"The next step changes to match.","product-aura.605b9e7726":"redirect mid-run","product-aura.6fc8843bbe":"no new session needed","product-aura.cb89bf6c01":"The project then tells Aura whether the change actually helped.","product-aura.b0d13e64c7":"You asked for one bug fix","product-aura.baf9fe09b5":"The first patch changed five files.","product-aura.a4124a140c":"You ran the tests yourself, and you pasted the failure back into the chat.","product-aura.972d89840a":"You explained the same project rule again, and you undid half the patch by hand.","product-aura.f70a4963d0":"One fix, all your work","product-aura.fc41e5073a":"The first patch, five files","product-aura.d5e7b6e73a":"The tests, run by you","product-aura.1e482820f3":"The failure, pasted back","product-aura.fb8d943f9b":"Half the patch, undone by hand","product-aura.7ac03a1987":"You were closing the loop. Aura does it with you.","product-aura.a60f2c7360":"Quality","product-aura.79bdcc199b":"gets the last word.","product-aura.9d4bf18e22":"Aura can run the project formatting, linting, compilation, tests, documentation checks, and audit stages. A failure goes back into the task. Aura can inspect it and correct the work instead of leaving you with a plausible patch and a broken build.","product-aura.bf36d53523":"When something fails, the failure goes back into the loop. Aura can fix the cause instead of merely reporting that the first patch looked reasonable.","product-aura.636f77e04c":"RUNS THE CHECKS","product-aura.6b91786646":"FAILURE GOES BACK IN","product-aura.765aa60565":"FIXES THE CAUSE","product-aura.c9516c76ce":"The checks it runs","product-aura.420695d8d8":"a failure returns to the task","product-aura.1425df5292":"Format and lint","product-aura.cd784df88b":"The style the project expects.","product-aura.a4577f1a58":"The build has to succeed.","product-aura.c7fafc7e4e":"A failure returns to the loop.","product-aura.6908c02cf7":"The project security stage runs too.","product-aura.2a667eb1b1":"a plausible patch is not enough","product-aura.d403cb4090":"the build has to pass","product-aura.c1b045ac27":"Wrong turns remain recoverable.","product-aura.ea924f72d3":"Recovery","product-aura.5f615695e9":"Try the change","product-aura.e203764391":"and keep the way back.","product-aura.8003bf3562":"Aura captures checkpoints before supported file edits. Undo the last change or several retained changes. Use a Git worktree for larger experiments that should stay away from the main branch. The timeline keeps a restore point for each step, so trying a different approach stays a normal move rather than a recovery project. Undoing one checkpoint or several is a single action.","product-aura.e55da5bcfe":"Trying a different approach does not have to become a recovery project. This does not replace Git. It gives the live loop a finer-grained way back between commits.","product-aura.b8415a5444":"CHECKPOINTS FIRST","product-aura.806e20a848":"UNDO ONE OR MANY","product-aura.67148e8d2a":"WORKTREE FOR BIG WORK","product-aura.4965db7102":"A checkpoint timeline","product-aura.2f26ac4bd0":"and a worktree branch","product-aura.32f23a470a":"Undo one","product-aura.92db2db7f8":"Roll back the latest change.","product-aura.bf575708b5":"Undo several","product-aura.550b67ed47":"Step back across retained checkpoints.","product-aura.9383193093":"Keep a big experiment off the main tree.","product-aura.3a4a336b84":"try the change","product-aura.8d95394625":"keep the way back","product-aura.3e7eb03dc5":"The next session should not forget the lesson.","product-aura.1965001def":"Correct it once.","product-aura.b642b5203d":"Keep the correction.","product-aura.ac15432d06":"Aura can remember selected preferences, project facts, learned patterns, and corrections across sessions. You can inspect, search, add, or forget them. Project instructions and custom agents can live in the project itself.","product-aura.24e2539930":"A correction becomes a memory you can see and remove, then appears in a later plan. The project memory remains even when the helper changes.","product-aura.a3461f360e":"REMEMBERS WHAT MATTERS","product-aura.3182bc7cc3":"YOU CAN FORGET IT","product-aura.9147230d54":"LIVES IN THE PROJECT","product-aura.8d5852ec4c":"A correction becomes memory","product-aura.eca194480e":"with a visible forget action","product-aura.97ee68a6da":"You fix a wrong assumption once.","product-aura.466fc49274":"Keep","product-aura.28edc214fc":"It becomes a memory you can see.","product-aura.52ec49203e":"Reuse","product-aura.9a84da9940":"It appears in a later plan.","product-aura.6d14cdfd37":"You remove it whenever you want.","product-aura.84985463a6":"correct it once","product-aura.61ec3e46a9":"do not repeat it every session","product-aura.3776159534":"The project memory remains even when the helper changes.","product-aura.ac23228277":"Pick the brain you trust","product-aura.e94095053d":"local or in the cloud.","product-aura.6b11dd8fcd":"Aura works with several set-up helpers and compatible services. A helper on your computer can keep the thinking with you. A helper in the cloud only receives what you choose to send. You can let Aura pick among the options you set up, with a fallback for when one is unavailable.","product-aura.3221584255":"A simple task can use a lighter helper. A harder task can use a stronger one. A fallback can step in when one is unavailable.","product-aura.55c5ebb781":"LOCAL OR CLOUD","product-aura.f619daea4c":"YOUR PROVIDER WORKS","product-aura.c71a08438a":"ROUTING WHEN YOU WANT IT","product-aura.438538ab77":"Four ways to choose","product-aura.6b863e645d":"the locality shown honestly","product-aura.dc99d54d99":"Local","product-aura.3b980043d4":"Inference can stay in your environment.","product-aura.237dfa0a21":"Private","product-aura.b2efeaa1a7":"Cloud","product-aura.6f0198baeb":"Receives the context you send.","product-aura.751dd54fa8":"Advisory","product-aura.2e8e972ea4":"use the model you choose","product-aura.850ff2fc0a":"the loop stays the same","product-aura.caca0636a3":"One session is useful. Several turn repeated work into a system.","product-aura.4ca0a75c2b":"Workspace","product-aura.2fe2ab710b":"Tabs, sessions, workflows,","product-aura.49f2cb6ccf":"and background work.","product-aura.d8f93fa1ab":"Keep several projects open at once, return to saved sessions, and start built-in workflows for debugging, features, and review. Longer jobs can continue in the background, with a clear status and a cancel button.","product-aura.f985077893":"One keyboard-first workspace keeps your sessions, files, changes, search, checks, helpers, tools, and activity record together. Larger jobs can bring in more than one helper.","product-aura.bed229a8d2":"TABS AND SESSIONS","product-aura.18f8680314":"BUILT-IN WORKFLOWS","product-aura.c09b44e27a":"One keyboard-first space","product-aura.566d134f8b":"several tasks at once","product-aura.2a4d562b1d":"Tabs","product-aura.5fad47f1d5":"Several project sessions open at once.","product-aura.ff2fdba77d":"Debug, feature, refactor, review.","product-aura.9d748e5542":"Long work with status and cancellation.","product-aura.3cbe6d6b9a":"Restore","product-aura.bbc6f9cc99":"Reopen a saved session where you left off.","product-aura.0583f1aad0":"many tasks","product-aura.456e7bb250":"one workspace","product-aura.155c141e54":"Larger work can bring in more than one helper.","product-aura.7ddbce5e77":"Several agents","product-aura.daf905a0b8":"Specialists hand work over","product-aura.153e616f93":"inside the same project.","product-aura.ade9411946":"Aura can run agent chains, parallel attempts, coordinated teams, and background tasks where the selected build enables them. Handoffs stay visible, result aggregation is explicit, and file claims reduce silent collisions.","product-aura.43016d423e":"You do not have to become the copy-and-paste layer between several coding tools. File claims mean two sessions do not silently edit the same path.","product-aura.34990ec996":"CHAINS AND TEAMS","product-aura.731f2153f9":"VISIBLE HANDOFFS","product-aura.1a754f9fbc":"FILE CLAIMS","product-aura.9e9783410f":"Helpers on one board","product-aura.c6432958c5":"each with a claim","product-aura.c84fe40941":"One specialist hands work to the next.","product-aura.765af67fdb":"Several attempts, explicit aggregation.","product-aura.b8a4265cc1":"A shared board and visible handoffs.","product-aura.06e8db2dfd":"Claims","product-aura.9a4cb99897":"No two agents edit the same file silently.","product-aura.133bda4d19":"more help","product-aura.c949f2ddcb":"no copy and paste","product-aura.5e94af4c2d":"The completed task should leave more than a diff.","product-aura.a0d961d622":"You see what changed","product-aura.29b9c6fc19":"and how it happened.","product-aura.f45954907c":"Aura can record the observable work in a tamper-evident sequence: which helper answered, tools, file actions, Guardian events, tidy-ups, and session state. Verify the chain later to detect any change. The receipt reads in plain rows: the goal, the files, the tools, the checks, the approval you gave, and the final state. Nothing in it can be quietly edited, so a run you did not sit and watch can still be read back afterwards, in the order it happened, by anyone you choose to show it to.","product-aura.e883a3a0f9":"You can inspect which tools ran, which files changed, which helper was chosen, and what happened during the session. It shows you exactly what changed. The record tells you how it happened.","product-aura.3ee46af548":"AN OBSERVABLE RECORD","product-aura.806ea17fa6":"VERIFY IT LATER","product-aura.bfcd179fd5":"A friendly session receipt","product-aura.f83c1391ce":"in plain rows","product-aura.62989aaaf9":"Goal and files","product-aura.35435ccd4a":"What you asked and what changed.","product-aura.2ce517f9fd":"Tools and checks","product-aura.e23332ffea":"What ran and what passed.","product-aura.8cc047ac17":"Approval","product-aura.046d55d6c4":"What you allowed along the way.","product-aura.0bccb266cf":"Audit valid","product-aura.bc7c8b4b17":"The chain verifies later.","product-aura.01e87a65d9":"the diff shows what","product-aura.6261aff8fd":"the record shows how","product-aura.0037bb57ac":"Start with one real task and let the goal decide when it is done.","product-aura.1ec5fc5f3e":"Start with one real task. Tell Aura what success looks like.","product-aura.55600968c8":"Run Aura in the project directory, choose the helper and permissions, set the goal, and watch it plan, act, check, correct, and wait for your direction.","product-aura.926fe901b0":"What you keep in control of","product-aura.68c46e84d7":"plain","product-aura.1060a65779":"language in","product-aura.b63989149a":"Describe the work, not the tool sequence","product-aura.922cce49ed":"yours","product-aura.5256675618":"permissions and access","product-aura.821f18128b":"Run, ask, or never, project-scoped by default","product-aura.5c6fa26f49":"undo","product-aura.c5925b4052":"checkpoints and worktrees","product-aura.5c9c26eb55":"Try the change, keep the way back","product-aura.86a4261d84":"verify","product-aura.23db5cb79f":"the record later","product-aura.a65fae6aaf":"Any editor, cross-session memory, audit when enabled","product-aura.a582ec34e3":"The loop","product-aura.cb3561211c":"See the whole loop","product-aura.bf43066654":"before the detail.","product-aura.c404e9a222":"One task travels the full circle: look at the project, plan the work, make the change, check the result, ask when unsure, finish when the goal is met. Everything else on this page is this circle made dependable, with your team holding the controls.","product-aura.758ef22382":"one circle","product-aura.1666817b31":"your team in control","product-aura.178513d536":"The loop,","product-aura.35a88b008c":"as a state machine.","product-aura.262d082157":"Plan states across the top, control states on the way back, the model as one replaceable node in the middle. Every capability that follows hangs off a specific edge of this machine, which is why the behaviour stays explainable under load.","product-aura.06c6d1b10d":"states and edges","product-aura.15a650b843":"the model is one node","product-aura.391c4ae139":"The helper circle","product-aura.355350fdcd":"A helper that checks","product-aura.3b6f7043c9":"its own work.","product-aura.ea45f89af7":"You describe what you want. The helper looks at your project, makes a plan, does the work, and then actually checks whether it worked before telling you it is done. If something is off, it tries again or asks you, instead of guessing.","product-aura.e4d1ed6182":"it checks before done","product-aura.1371f681b2":"it asks when unsure","product-aura.4d89a1a155":"you prompt and read it","product-aura.854a3de2da":"you run each command","product-aura.847c7aaeed":"you launch the suite","product-aura.e3d128a96d":"you stage and commit","product-aura.0f9308efcd":"you scan the change","product-aura.e4e392ac2e":"you move the card","product-aura.2fdfc1ad50":"you open the request","product-aura.6f6cc917b8":"accept the next step","product-aura.d58404d486":"change the direction","product-aura.65b646293d":"hold the run","product-aura.0995c3ca46":"stop the run now","product-aura.2cc21c365d":"roll the change back","product-aura.cb918a8203":"the success criteria","product-aura.558d83c148":"the steps to try","product-aura.142953bf84":"run the bounded tools","product-aura.d24d24ffa4":"read the real result","product-aura.c0b5db68c6":"accept a correction","product-aura.de5843504e":"check each criterion","product-aura.6683d02ad3":"met or not met","product-aura.3f6b5910de":"close, or loop again","product-aura.a38b15bd25":"style is applied","product-aura.0bcf493466":"warnings are cleared","product-aura.f2db289b9c":"the build is clean","product-aura.b1d622ac51":"the suite passes","product-aura.98ff588f92":"policy is checked","product-aura.f018b4c5f0":"renders the live stream","product-aura.379a583a44":"appends to the chain","product-aura.337afb8f83":"counts tokens and turns","product-aura.3875776784":"watches for stalls","product-aura.f7a5aa1a1c":"tracks the plan","product-aura.cfc5a1eddc":"hook custom handlers","product-aura.99d90b66cf":"Your project","product-aura.5b981e08b7":"The brain","product-aura.993be5786a":"Give it the goal and the boundary","product-aura.bf6a219220":"and the definition of done","product-aura.df5476f019":"Give it a real repository","product-aura.59b76060f9":"and an executable definition of done","product-aura.e3efe2b488":"Start with one real task","product-aura.ec94d0e859":"and say what success looks like","product-aura.bd9f949e9e":"What the loop holds to","product-aura.2ff255684a":"Completion","product-aura.a58dbdeb8f":"Checked against explicit success criteria","product-aura.d06d555709":"Permissions","product-aura.2fa4554e2e":"Always, Ask or Never, set per project","product-aura.cb8374fa41":"Tamper-evident and hash-chained","product-aura.416f714626":"Every run leaves a record you can verify later.","section_st_a2_split-spec-sheet.7c9a7c0610":"Detail","section_st_a6_split-scenario-triad.f75fd3a884":"No runtime deps","section_st_a6_split-scenario-triad.143ac4ef35":"Single binary","section_st_a6_split-scenario-triad.c61f134d87":"Three surfaces","section_st_a6_split-scenario-triad.215475056e":"WHERE IT RUNS","section_st_a6_split-scenario-triad.a794a586f0":"Sealed-room ready","section_st_a6_split-scenario-triad.42d52c32ea":"Local model","section_st_a6_split-scenario-triad.fe6168e59f":"No network","section_st_a6_split-scenario-triad.7d93f83c3e":"Volume-mounted code","section_st_a6_split-scenario-triad.bee0cb05f8":"Kubernetes","section_st_a6_split-scenario-triad.9f1141549f":"Docker","section_st_a6_split-scenario-triad.5315129cfe":"macOS, Linux, Windows","section_st_a6_split-scenario-triad.a89193f674":"No install","section_st_a6_split-scenario-triad.f600b9e709":"One binary","section_st_a7_split-connector-grid.4e6822a6d4":"Hot-reload","section_st_a7_split-connector-grid.19e35f0609":"Set in TOML","section_st_a7_split-connector-grid.d9de50b343":"Caller-driven inventory","section_st_a7_split-connector-grid.8be1bb51b7":"CONNECTORS","section_st_a8_split-scaling-profile.7e0861e04c":"Tunable in TOML","section_st_a8_split-scaling-profile.56d6732417":"Per-project ceiling","section_st_a8_split-scaling-profile.27a454915b":"Active dots reflect concurrent agents per tier.","section_st_a8_split-scaling-profile.0ea215ea0d":"BACKGROUND","section_st_a8_split-scaling-profile.9fc6fb7e03":"TEAMS","section_st_a8_split-scaling-profile.018d2cd1a5":"PARALLEL","section_st_a8_split-scaling-profile.16623c5d4a":"CHAINS","section_st_a8_split-scaling-profile.0fb79c96ed":"Solo → Team → Network","section_st_a8_split-scaling-profile.068f6b3ecc":"TEAM SCALE","section_st_a8_split-scaling-profile.53ebc572b4":"Network","section_st_a8_split-scaling-profile.218887269a":"Team","section_st_a8_split-scaling-profile.9fc93acaa4":"Solo","section_st_a9_split-time-lost-donut.7c9a7c0610":"Detail","section_st_b5_request-lifecycle.47e364232a":"audit #4521","section_st_b5_request-lifecycle.4d3535f846":"patch · session.rs","section_st_b5_request-lifecycle.6c2519cd62":"Tool execution","section_st_b5_request-lifecycle.f6d1c823ab":"session #128 · 14:02","section_st_b5_request-lifecycle.636de0d0c3":"> \"fix this bug\"","section_st_b5_request-lifecycle.0208131a7d":"User request","section_st_b7_audit-chain.9239506454":"0d4e · 8f2c · 51a9 · 73be","section_st_b7_audit-chain.a383df4adb":"a015 · 7c93 · 3e6f · d28b","section_st_b7_audit-chain.efd3faebc5":"9e1b · 22a7 · 8d50 · 6b3c","section_st_b7_audit-chain.4df252b458":"4f2a · b7d1 · 1c83 · e0a4","section_st_b8_defense-stack.eee0f04cba":"YOUR CODEBASE","section_st_b8_defense-stack.89b6e2a784":"DEFENCE IN DEPTH","section_st_c2_dual-loop-flow.9d29573ea6":"tool / step","section_st_c2_dual-loop-flow.08ab1ac55a":"plan / replan","section_st_c5_integration-spoke.55d0677ac3":"All connectors funnel through the same audit + permission layer.","section_st_c5_integration-spoke.c29eb7e425":"Local agent","section_st_c5_integration-spoke.14afd82a7f":"AURA","section_st_c5_integration-spoke.ed0afbab5a":"GitLab CI","section_st_c5_integration-spoke.39540900bb":"GitHub Actions","section_st_c5_integration-spoke.a2feefe9af":"Jenkins","section_st_c5_integration-spoke.ab4115a7b2":"External tools","section_st_c5_integration-spoke.70c123381f":"JSON-RPC 2.0","section_st_c5_integration-spoke.dc99d54d99":"Local","section_st_c5_integration-spoke.6466df1d3d":"Mistral","section_st_c5_integration-spoke.a19ee5a9fd":"OpenAI","section_st_c5_integration-spoke.b780a23b53":"Anthropic","section_st_f1_cta-dark.90e40d5043":"Get started","toc-rail.f5cbdf6bfb":"Contents"}